Java学习之内部类与常用类

内部类

1.内部类的分类

2.什么是内部类

• 概念：在一个类中再定义一个完整的类
• 特点：
  • 编译之后可以生成独立的字节码文件
  • 内部类可直接访问外部类的私有成员，而不破坏封装
  • 可为外部类提供必要的内部功能组件

3.成员内部类

• 在类的内部定义，与实例变量，实例方法同级别的类
• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象

public class Test {
    public static void main(String[] args) {
      /*  Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();*/
        Outer.Inner inner=new Outer().new Inner();
        inner.test();
    }
}

• 当外部类，内部类存在重名属性时，会优先访问内部类属性，要访问外部类的属性就要使用——外部类名.this.属性名

public class Outer {
    private String name="张三";
    private String password="123456";
    class Inner{
        private int age=12;
        private String name="李四";
        void test(){
            System.out.println(Outer.this.password);
            System.out.println(Outer.this.name);
            System.out.println(age);
            System.out.println("test");
        }
    }
}

• 成员内部类不能定义静态成员，常量可以

4.静态内部类

• 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员
• 静态类和外部类相同

5.局部内部类

• 定义在外部类方法中，作用范围和创建对象范围仅限在当前方法
• 局部内部类访问局部变量，jdk1.7要求变量必须是常量final，jdk1.8自动添加final

6.匿名内部类

• 没有类名的局部内部类
• 必须继承一个父类或者实现一个接口
• 定义类，实现类，创建对象的语法合并，只能创建一个该类的对象
• 优点：减少代码量
• 缺点：可读性较差

Object类

• 超类，基类，所有类的直接或间接父类，位于继承树的最顶层
• 任何类默认继承Object
• Object类所定义的方法，是所有对象都具备的方法
• Object类型可以存储任何对象

Object类常用方法

1.getClass()方法

• public final Class<?> getClass(){}
• 返回引用中存储的实际对象类型
• 判断两个引用类型实际存储的对象类型是否一致

2.hashCode()

• public int hashcode(){}
• 返回该对象的哈希码值
• 哈希值根据对象的地址或字符串或数字使用hash算法来得到一个int类型的数值
• 一般情况下相同对象返回相同哈希码值

3.toString()方法

• public string toString()方法
• 返回该对象的字符串表示
• 可以根据需求重写该方法

4.equals()方法

• public boolean equals(Object obj){}
• 默认实现为(this==obj),比较两个地址是否相同
• 可进行覆盖，比较两个对象的内容是否相同
• equals()方法覆盖步骤
  • 比较两个引用是否指向同一个对象
  • 判断obj是否为null
  • 判断两个引用指向的实际对象类型是否一致
  • 强制类型转换
  • 依次比较各个属性值是否相同

5.finalize()方法

• 当对象判定为垃圾对象时，由jvm自动调用这个方法，用以标记垃圾对象进入回收队列
• 垃圾对象：没有有效的引用指向此对象时，为垃圾对象
• 垃圾回收：由GC销毁垃圾对象，释放数据存储空间
• 自动回收机制：jvm的内存耗尽，一次性回收所有的垃圾对象
• 手动回收机制：使用System.gc();通知jvm执行回收垃圾

包装类

• 基本数据类型所对应的引用数据类型
• Object可以统一所有数据，包装列默认值是null
• 对应的包装类
  

1.类型转换与装箱，拆箱

public class Demo1 {
    public static void main(String[] args) {
        //装箱  基本数据类型转引用类型
        int num=22;
        //装箱的两个方式
        Integer integer = new Integer(num);
        Integer integer1=Integer.valueOf(num);
        
        //拆箱  引用类型转基本数据类型
        Integer integer2 = new Integer(10);
        int i = integer2.intValue();

        //jdk1.5之后自动装箱拆箱
        int age=22;
        Integer integer3=age;
        int age2= integer3;
    }
}

2.基本数据类型和字符串之间的转换

public class Demo2 {
    public static void main(String[] args) {
        //基本数据类型和字符串之间的转换
        //1.基本类型转为字符串
        //1.1使用+号
        int num=22;
        String n=num+"";
        //1.2使用Integer.toString()方法
        String s = Integer.toString(num);

        //字符串转为基本类型
        //1.使用Integer.parseInt()方法
        String str="200";
        int i = Integer.parseInt(str);

        //boolean字符串形式转成基本数据类型 "true"--》true  非"true"--》false
        String b="true";
        boolean b1 = Boolean.parseBoolean(b);
        
    }
}

3.整数缓冲区

• Java预先创建了256个常用的整数包装类型对象
• 自动装箱是调用了valueOf()方法
  如果装箱数值在-128到127 就在缓冲区取，否则就new Integer(数值),构造方法来装箱

String类

1.String

• 字符串是常量，创建之后不可以改变
• 字符串字面值存储在字符串池中，可以共享

public class Demo3 {
    public static void main(String[] args) {
        String name="Hello";
        name="张三";
    }
}

public class Demo3 {
    public static void main(String[] args) {
        String name="Hello";
        name="张三";
        String name2="张三";
    }
}

public class Demo3 {
    public static void main(String[] args) {
        String name="Hello";
        name="张三";
        String name2="张三";

        //字符串的另一种创建方式
        String str1 = new String("java");
        String str2 = new String("java");
        System.out.println(str1==str2);//false
        System.out.println(str1.equals(str2));//true
    }
}

2.常用方法

• public int length():返回字符串长度
• public char chaAt(int index):根据下标获取字符
• public boolean contains(String str):判断当前字符串中是否包含str
• public char[] toCharArray:将字符串转为字符数组
• public int indexOf(String str):查找str首次出现的下标，存在，则返回下标，不存在，返回-1
• public int lastIndexOf(String str)：查找字符串在当前字符串中最后一次出现的下标索引

public class Demo4 {
    public static void main(String[] args) {
        //返回字符串长度
        String name="sjkkjdf";
        int length = name.length();
        System.out.println(length);
        //返回字符串的下标字符
        char c = name.charAt(2);
        System.out.println(c);
        //判断当前字符串中是否包含str
        boolean jk = name.contains("jk");
        System.out.println(jk);
        //将字符串转为字符数组
        char[] chars = name.toCharArray();
        for (char aChar : chars) {
            System.out.println(aChar);
        }
        //查找str首次出现的下标，存在，则返回下标，不存在，返回-1
        int jk1 = name.indexOf("jk");
        int os = name.indexOf("os");
        System.out.println(jk1);
        System.out.println(os);
        //查找字符串在当前字符串中最后一次出现的下标索引,没有就返回-1
        int jk2 = name.indexOf("jk");
        int os1 = name.indexOf("os");
        System.out.println(jk2);
        System.out.println(os1);
    }
}

• public String trim():去掉字符串的前后空格
• public String toUpperCase():将小写转成大写
• public boolean endWith(String str):判断字符是否以str结尾

public class Demo5 {
    public static void main(String[] args) {
        String name=" sd sdf ffs ";
        //去掉字符串的前后空格
        String trim = name.trim();
        System.out.println(trim);
        //将小写转成大写
        String s = name.toUpperCase();
        System.out.println(s);
        //判断字符是否以str结尾
        boolean s1 = name.endsWith("s");
        System.out.println(s1);
    }
}

• public String replace(char oldChar,cha nemChar):将旧字符串替换成新字符串
• public String[] split(String str):根据str做拆分

public class Demo6 {
    public static void main(String[] args) {
        String name="Hello java";
        //将旧字符串替换成新字符串
        String replace = name.replace("java", "php");
        System.out.println(replace);
        //根据str做拆分
        String[] split = name.split("\\s+");//空格转义字符\s,\必须转义，+代表1个或多个
        System.out.println(Arrays.toString(split));
    }
}

public class Demo7 {
    public static void main(String[] args) {
        //补充两个方法
        String s1 = "hello";
        String s2 = "HELLO";
        //忽视大小写判断值是否相同
        System.out.println(s1.equalsIgnoreCase(s2));

        //判断两个字符串的大小，一个一个字符相减来比较
        String s3 = "abc"; //97
        String s4 = "xyz";//120
        System.out.println(s3.compareTo(s4));
        //如果两个字符串前面的字符串都相同，那么就用位数来相减
        String s5="abc";
        String s6="abcdef";
        System.out.println(s5.compareTo(s6));
    }
}

3.综合练习

public class Demo8 {
    public static void main(String[] args) {
        String str="this is a text";
        String[] split = str.split("\\s+");
        for (String s : split) {
            System.out.println(s);
        }
        String replace = str.replace("text", "practice");
        System.out.println(replace);
        String replace1 = str.replace("text", "easy text");
        System.out.println(replace1);
        for (int i = 0; i <split.length ; i++) {
            char c = split[i].charAt(0);
            char c1 = Character.toUpperCase(c);
            String s = c1 + split[i].substring(1);
            System.out.println(s);
        }
    }
}

4.可变长字符串

• StringBuffer：可变长字符串，jdk1.0提供，运行效率低，线程安全

public class Demo9 {
    public static void main(String[] args) {
        StringBuffer stringBuffer = new StringBuffer();
        //1.追加
        StringBuffer s1 = stringBuffer.append("java真好啊");
        System.out.println(s1.toString());
        //2.insert插入
        s1.insert(4,"真香啊");
        System.out.println(s1.toString());
        //3.replace
        s1.replace(0,4,"php");
        System.out.println(s1.toString());
        //4.delete
        s1.delete(0,3);
        System.out.println(s1.toString());
    }
}

• StringBuilder：可变长字符串，jdk5.0提供，运行效率高，线程不安全

public class Demo9 {
    public static void main(String[] args) {
        StringBuilder stringBuilder = new StringBuilder();
        //1.追加
        StringBuilder s1 =  stringBuilder.append("java真好啊");
        System.out.println(s1.toString());
        //2.insert插入
        s1.insert(4,"真香啊");
        System.out.println(s1.toString());
        //3.replace
        s1.replace(0,4,"php");
        System.out.println(s1.toString());
        //4.delete
        s1.delete(0,3);
        System.out.println(s1.toString());
    }
}

BigDecimal类

• 很多应用场景是需要精确计算的，double，float都是近似值存储，不符合要求，需要借助BigDecimal
• 位置：java.math包
• 作用：精确计算浮点数
• 创建方式：BigDecimal bd=new BigDecima(“1.0”）;
• 方法：
  • BigDecimal add(BigDecimal bd) //相加
  • BigDecimal substract(BigDecimal bd) //相减
  • BigDecimal dividet(BigDecimal bd) //相除
  • BigDecimal multiply(BigDecimal bd) //相乘
• 除法：divide(BigDecimal bd,int scal,RoundingMode mode)
• 参数scal：指定精确小数点后几位
• 参数mode：
  • 指定小数部分的取舍模式，通常采用四舍五入的模式
  • 取值为BigDecimal.ROUND_HALF_UP

Date类

• Date表示特定的瞬间，精确到毫秒。jdk1.1后Date类大部分方法都被Calendar类中的方法取代
• 时间单位
  • 1秒=1000毫秒
  • 1毫秒=1000微妙
  • 1微妙=1000纳秒

Calendar类

• Calendar提供了获取或设置各种日历字段的方法
• 构造方法
  • protected Calendar()：由于修饰符是protected，所以无法直接创建对象
• 其他方法：
  

public class Demo11 {
    public static void main(String[] args) {
        //创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        //1.设置年月日时分秒
        calendar.set(2018,3,3,2,2,2);
        //2.返回一个Date表示的时间
        System.out.println(calendar.getTime());
        System.out.println(calendar.getTime().toLocaleString());
        //3.以毫秒为单位返回该日历的时间值
        System.out.println(calendar.getTimeInMillis());
        //4.返回日历字符值
        int i = calendar.get(Calendar.MONTH);
        System.out.println(i);
        //5.增加指定字段时间量
        calendar.add(Calendar.YEAR,1);
        System.out.println(calendar.getTime().toLocaleString());
        //6.获取该字段的最大最小值
        int maximum = calendar.getMaximum(Calendar.MONTH);
        int minimum = calendar.getMinimum(Calendar.YEAR);
        System.out.println(maximum);
        System.out.println(minimum);
        //7.获取该字段有多少其他字段的最大最小值 比如1月份有31天
        int actualMaximum = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
        int actualMinimum = calendar.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(actualMaximum);
        System.out.println(actualMinimum);
    }
}

SimpleDateFormat类

• SimpleDateFormat是一个以语言环境有关的方式来格式化和解析日期的具体类
• 进行格式化(日期-》文本)，解析（文本-》日期）
• 常用的时间模式字母
  

public class Demo12 {
    public static void main(String[] args) throws ParseException {
        //格式化
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd HH-mm-ss");
        Date date = new Date();
        String format = simpleDateFormat.format(date);
        System.out.println(format);
        //解析
        Date parse = simpleDateFormat.parse("2013/12/20 12-12-12");
        System.out.println(parse);
    }
}

System类

• System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的