内部类与常用类

内部类

概念:在一个类的内部再定义一个完整的类。
特点

（1）编译之后可生成独立的字节码文件。

编译内部类

（2）内部类可直接访问外部类的私有成员,而不破坏封装。

（3）可为外部类提供必要的内部功能组件。

成员内部类

特点：
（1）当外部类和内部类重命时，优先访问内部类
（2）成员内部类不能定义静态成员

public class MemberInnerClass{
    public static void main(String[] args) {
    
        Outer out = new Outer();            // 创建一个外部类对象
        Outer.Inner in = out.new Inner();   // 创建一个内部类对象（必须依赖外部类对象）创建语法特殊
        System.out.println(in.b);           // 调用成员内部类的变量
        in.xiao();                          // 调用成员内部类的方法
//      System.out.println(out.a);          // 报错，无法访问Outer类的私有属性
//      Outer.Inner.field                   //Error 无法脱离外部类对象进行静态的调用

    }
}

class Outer{
    private int a = 33;
    private String c = "xiao";

    class Inner{                                         // 成员内部类，依赖外部类
//      static String field = "abc";                     //成员内部类不能定义静态成员    
        int b = 5;
        int a = 66;
        public void xiao(){
            int a = 99;
            System.out.println("xiao一xiao" +" " + c);  // 内部类可以直接访问外部类对象
            System.out.println(a);                     //内部类可以直接访问自身的局部变量
            System.out.println(this.a);                //内部类可以访问内部类的实例变量
            System.out.println(Outer.this.a);          //内部类可以访问外部类实例变量
        }
    }
}

静态内部类

public class TestStaticClass {
    public static void main(String[] args) {
        //外部类的静态属性
        System.out.println(Outer.a);
        //外部类的静态方法
        Outer.m1();         
        //创建静态内部类对象时，可以直接通过完整名称进行创建
        Outer.Inner in = new Outer.Inner();     //静态内部类的创建，不依赖外部类的对象        
        //创建内部类对象后，访问实例属性和方法
        System.out.println(in.b);
        in.m2();
        //&&额外比成员内部类多了一个定义的内容（静态属性和静态方法）&&      
        //通过外部类类名.内部类类名.内部类的静态属性
        System.out.println(Outer.Inner.field);
        //通过外部类类名.内部类类名.内部类的静态方法
        Outer.Inner.m3();

    }
}

class Outer{                                       // 外部类
    static int a = 10;
    static class Inner{                            // 静态内部类
        int b = 20; 
        static String field = "abc";    
        public void m2(){
            System.out.println("Inner m2()");
        }   
        public static void m3(){
            System.out.println(a);
        }   
    }   
    static void m1(){
        System.out.println("Outer m1()");
    }
}

局部内部类

特点：
（1）定义在外部类方法中，作用范围和创建对象范围仅限于当前方法
（2）局部内部类访问外部类当前方法中的局部变量是，因无法保障变量的生命周期与自身相同，变量必须修饰为final
（3）限制类的使用范围

匿名内部类

Object类

getClass() 方法
作用：获取对象的真实类的全名称
应用：判断两个引用中实际存储对象类型是否一致
一般和getName()联合使用，如getClass().getName();
hashCode() 方法
作用：返回该对象的哈希码值
特点：不同对象的 hashCode() 的值一般是不相同。但是，同一个对象的hashCode() 值肯定相同
toString() 方法
作用：返回该对象的字符串表示
equals() 方法
作用：指示其他某个对象是否与此对象“相等”

public class ObjectToString {
    public static void main(String[] args) {
        Student s = new Student();                  // 创建学生对象 s
        System.out.println("输出学生对象s的 对象类型 :" + s.getClass());           // 输出学生对象s的 对象类型
        Object o = new Object();                    // 创建Object对象o 
        System.out.println("输出o对象的 对象类型: " + o.getClass());             // 输出o对象的 对象类型
        Animal d = new Dog();                       // 创建Dog对象d
        System.out.println("输出d对象的 对象类型: " + d.getClass());             // 输出d对象的 对象类型
        System.out.println("输出d对象的 对象类型: " + d.getClass().getName());   // 输出d对象的 名称
        Animal a1 = new Cat();
        Object a2 = new Cat();  
        if(a1.getClass() == a2.getClass()){      // a1、a2对象都是Cat类型，所以一样
            System.out.println("一样");
        }else{
            System.out.println("不一样");
        }
        System.out.println(a1.hashCode());      // 返回该对象的哈希码值
        System.out.println(a1.toString());      // 返回a1对象的字符串表示
        System.out.println(a1.equals(a1));      // equals比较的是内容  
        System.out.println(a1==a2);             // == 比较的是地址

    }
}

class Student{}
class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}
class Bird extends Animal{}

包装类

使用

public class Test4 {
    public static void main(String[] args) {
        boolean x = true;
        // 通过构造器把x基本数据类型变量包装成包装类对象
        Boolean xObj = new Boolean(x);
        int y = 5;
        // 通过构造器把y基本数据类型变量包装成包装类对象
        Integer yObj = new Integer(y);
        float z = 3.14f;
        // 通过构造器把z基本数据类型变量包装成包装类对象
        Float  zObj = new Float(z);
        
        // 取出Boolean对象里的boolean变量
        boolean xx = xObj.booleanValue();
        System.out.println(xx);
        // 取出Integer对象里的Integer变量
        int yy = yObj.intValue();
        System.out.println(yy);
        // 取出Float对象里的Float变量
        float zz = zObj.floatValue();
        System.out.println(zz);
    }
}

自动装箱：把一个基本数据类型变量直接赋给对应的包装类变量（或者赋给Object变量）
自动拆箱：直接把包装类对象直接赋给一个对应的基本类型变量

public class Test4 {
    public static void main(String[] args) {
        // 把一个基本数据类型直接赋给Integer对象
        Integer xObj = 5;
        // 把一个boolean类型变量直接赋给Object变量
        Object boolObj = true;
        // 直接把一个Integer对象赋给int类型的变量
        int x = xObj;
    }
}

基本数据类型变量和字符串之间的转换

public class Test4 {
    public static void main(String[] args) {
        String intStr = "123";
        // 把一个特点的字符串转换成int变量
        int x = Integer.parseInt(intStr);
        System.out.println(x);
        
        String floatStr = "3.14159f";
        // 把一个特点的字符串转换成float变量
        float y = Float.parseFloat(floatStr);
        System.out.println(y);
        
        // 把一个float变量转换成String变量
        String z = String.valueOf(2.123f);
        System.out.println(z);
        System.out.println(z.getClass());     // 查看变量z的类型
    }
}

String 类

特点：字符串是常量，创建之后不可改变

public char charAt(int index):根据下标获取字符。
public boolean contains (String str):判断当前字符串中是否包含str()
public char[] toCharArray() :将字符串转换成数组。
public int indexOf (String str):查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1。
public int lastlndexOf (String str):查找字符串在当前字符串中最后一次出现的下标索引。
public int length():返回字符串的长度。
public String trim():去掉串前后的空格。
public String toUpperCase():将小写转成大写。
public boolean endWith(String str):判断字符串是否以str结尾。
public String replace (char oldChar，char newChar);将旧字符串替换成新字符串
public String[] split(String str):根据str做拆分。

public class StringClassMethodsUse {  
    public static void main(String[] args){  
       String xiao = " woshiyigemeiyouganqingdeshashou ";
       System.out.println(xiao.charAt(4));   // 根据下标获取字符
       System.out.println(xiao.contains("shi")); // 判断是否包含字符串
       char[] s = xiao.toCharArray();           // 将字符串转化为数组
       System.out.println(s[3]);
       System.out.println(xiao.indexOf("hi"));
       System.out.println(xiao.indexOf("z"));  // 查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
       System.out.println(xiao.lastIndexOf("sh"));
       System.out.println(xiao.lastIndexOf("z"));   // 查找str最后出现的下标，存在，则返回该下标；不存在，则返回-1
        System.out.println(xiao.length());   //返回字符串的长度。
        System.out.println(xiao.trim());     //去掉串前后的空格
        System.out.println(xiao.toUpperCase());  //将小写转成大写
       System.out.println(xiao.replace("sha", "xiao")); //将旧字符串替换成新字符串
    }   
}

StringBuffer类

特点：可以改变字符串的内容和长度

BigDecimal 类

public class BigDecimalAllMethodsUse {
    public static void main(String[] args) {
        BigDecimal bg1 = new BigDecimal("3.3");
        BigDecimal bg2 = new BigDecimal("2.3");
        
        BigDecimal result1 = bg1.add(bg2);      // 加
        System.out.println(result1);
        BigDecimal result2 = bg1.subtract(bg2);     // 减
        System.out.println(result2);
        BigDecimal result3 = bg1.multiply(bg2);     // 乘
        System.out.println(result3);
        BigDecimal result4 = bg1.divide(bg2,3,BigDecimal.ROUND_HALF_UP);// 除   3是保留小数点后3位，BigDecimal.ROUND_HALF_UP是4舍5入
        System.out.println(result4);
    }
}

Arrays类

public class ArraysClass {
    public static void main(String[] args) {
        String [] names = {"xiao","xian","hua","nian"};
        int [] age = {1,9,5,3,4,6};
        // 排序
        Arrays.sort(names);
        System.out.println(Arrays.toString(names));   // 将数组转换为字符串，顺序输出
        // 二分法查询元素在数组出现的索引
        Arrays.binarySearch(names,"xiao");
        System.out.println(Arrays.binarySearch(names,"xiao"));
        // 赋值数组到新数组  newLength 新数组长度
        String s[] = Arrays.copyOf(names,9);
        System.out.println(Arrays.toString(s));
        // 将数组 2-5 赋值为3
        Arrays.fill(age,2,4,4);
        System.out.println(Arrays.toString(age));
    }
}

Date类

public class DateClass {
    public static void main(String[] args) {
    Date date = new Date();
    System.out.println(date);  // 当前日期  Wed Apr 29 13:56:15 CST 2020
    //当前日期和时间进行格式化输出
    String a = String.format("%tF",date);    // 2020-04-29
    System.out.println(a); 
    String b = String.format("%tD",date);  // 04/29/20
    System.out.println(b);
    String c = String.format("%tr",date);  // 01:56:15 下午
    System.out.println(c); 
    String d = String.format("%tT",date);  // 13:56:15
    System.out.println(d);
    String e = String.format("%tR",date);  // 13:56
    System.out.println(e);
    //当前日期进行格式化输出
    String f = String.format(Locale.US,"%ta",date);    //Wed
    System.out.println(f);
    String g = String.format(Locale.US,"%tA",date);    //Wednesday
    System.out.println(g);
    String h = String.format("%ty",date);  //20
    System.out.println(h);
    String i = String.format("%tY",date);  //2020
    System.out.println(i);
    String j = String.format("%tm",date);  //04
    System.out.println(j);
    String k = String.format("%td",date);  //29
    System.out.println(k);
    String l = String.format("%te",date);  //29
    System.out.println(l);
    String m = String.format("%tj",date);  //120
    System.out.println(m);
    String n = String.format(Locale.US,"%tb",date);    //Apr
    System.out.println(n);
    String o = String.format(Locale.US,"%tB",date);    //April
    System.out.println(o);
    }
}

file 类

public class FileClass {
    public static void main(String[] args) throws IOException, InterruptedException {
        String path = "D:\\xiao";
        File file = new File(path);
        // 创建删除文件夹
        if (!file.exists()) {
            file.mkdir();               // 创建文件夹    mkdir()只会建立一级的文件夹
            file.mkdirs();              // 创建文件夹    mkdirs()可以建立多级文件夹
//            file.delete();              // 删除文件夹
        } else {
            System.out.println("该文件夹已存在");
        }
        //  创建、删除文件
        String filename = "xiao.txt";
        File myFile = new File(path, filename);
        if (!myFile.exists()) {
            myFile.createNewFile();     //  创建文件
//            myFile.delete();            // 删除文件
        } else {
            System.out.println("该文件夹已经存在");
        }
        // 文件函数
        //判断文件是否存在
        System.out.println(myFile.exists());
        //读取文件名称
        System.out.println(myFile.getName());
        //读取文件路径(相对路径)
        System.out.println(myFile.getPath());
        //读取文件绝对路径
        System.out.println(myFile.getAbsolutePath());
        //读取文件的父级路径
        System.out.println(new File(myFile.getAbsolutePath()).getParent());
        //读取文件的大小
        System.out.println(myFile.length());
        //判断文件是否被隐藏
        System.out.println(myFile.isHidden());
        //判断文件是否可读
        System.out.println(myFile.canRead());
        //判断文件是否可写
        System.out.println(myFile.canWrite());
        //判断文件是否为文件夹
        System.out.println(myFile.isDirectory());
    }
}

Scanner 类

public class ScannerClass {
   public static void main(String[] args) {
      String name;
      int age;
      String address;
      Scanner sc = new Scanner(System.in,"UTF-8");
      System.out.println("请输入姓名：");
      name = sc.nextLine();
      System.out.println("请输入年龄：");
      age = sc.nextInt();
      System.out.println("请输入地址：");
      address = sc.next();
      System.out.println("姓名： " + name);
      System.out.println("年龄： " + age);
      System.out.println("地址： " + address);  
   }
}