常用类的学习（一）

常用类的学习

1. 内部类

2. Object类

3. Object类常用方法

4. 包装类

5. String类

6. BigDecimal类

内部类和常用类概述

内部类分为

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

什么是内部类

概念：在一个类的部内部在定义一个完整的类

class Outer{
    class Inner{
        
    }
}

特点：

• 内部类也会生成独立的字节码文件（Class文件）
• 内部类可以直接访问外部类的私有成员，而不破坏封装

class Outer{
    private String name；
    class Inner{
        System.out.println(name);
    }
}

• 可以为外部类提供必要的功能组件

成员内部类

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

//外部类
class Outer{
    private String name = "张三";
    private int age = 20;
    
    //内部类 
    class Inner{
        private String address = "北京";
        private String phone = "110";
        
        //方法
        public void show(){
            //打印外部类的属性
            System.out.println(name);
            System.out.println(age);
            //打印内部类的属性
            System.out.println(address);
            System.out.println(phone);
        }
    }
}

public class Test{
    public static void main(String[] args){
        //创建外部类对象
        Outer outer = new Outer();
		//创建内部类对象
        Inner inner = outer.new Inner();//外部类的一个实例部分，在创建内部类对象时，必须依赖外部类对象
        //调用上面的方法
        inner.show();
        //一步到位的方法 Inner innner = new Outer().new Inner();
    }
}

• 当外部类和内部类存在重名属性时，会优先访问内部类属性

需要使用this关键字

class Outer{
    private String name = "张三";
    class Inner{
        private String name = "李四";
        public void show(){
            //会输出"李四"
            System.out.println(name);
            //输出"张三"
            System.out.println(this.name);
        }
    }
}

• 成员内部类不能定义静态成员

---

静态内部类

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

class Outer{
    private String name；
    static class Inner{
        private String address = "北京";
        private static int count = 1000;
        public void show(){
            //1先创建外部类对象属性
            Outer outer = new Outer();
            //2调用外部类对象的属性
            System.out,println(outer.name);
      		//调用静态内部类的属性和方法
            System.out,println(address);
            //调用静态内部类的静态属性 直接使用类名.静态变量名
            System.out,println(Inner.count);
        }
    }
}

• 只有内部类才可以使用static修饰

---

局部内部类

• 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。
• 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final。
• 限制类的使用范围，只能在当前的方法中使用

---

匿名内部类

• 没有类名的局部内部类（一切特征都与局部内部类相同）。
• 必须继承一个父类或者实现一个接口。
• 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。

优点：减少代码量

缺点：可读性较差

//接口
public interface Usb{
    //服务
    void service();
}

public class KeyBoard implements Usb{
    @Override 
    //重写服务方法
    void service(){
        System.out.println("连接电脑成功，键盘开始工作了");
    }
}

---

public class TestUsb{
    public static void main(String[] args){
        /*创建接口类型变量
        Usb usb = new KeyBoard();
        //输出 	连接电脑成功，键盘开始工作了
        usb.service();
        */
        //实现接口的局部内部类
        /*class Fan implements Usb{
            @Override
            public void service(){
                 System.out.println("连接电脑成功，风扇开始工作了");
            }
            
            //使用局部内部类创建对象
            Usb usb = new Fan();
            //输出  连接电脑成功，风扇开始工作了
            usb.service();
          */  
            //使用匿名内部类优化(相当于创建一个局部内部类)
            Usb usb = new Usb(){
                @Override
            public void service(){
                 System.out.println("连接电脑成功，风扇开始工作了");
            }
                //输出 连接电脑成功，风扇开始工作了
                usb.service();
                
        }
    }
    
}

笔记记录于B站“千锋教育-2020新版 Java常用类最新教程 通俗易懂”

King老师是一个非常优秀的老师

视频地址

欢迎大家一起学习！