常用类

内部类

1.成员内部类

通过内部类访问私有成员属性和方法

package com.zhang.oop.demo03clsaa;
public class Outer {
    private String name = "张三";
    private  int age = 20;
    class Inner{
        private String country = "中国";
        private String name = "李四";
        public void show(){
            System.out.println(Outer.this.name);  //张三
            System.out.println(name);     //李四
            System.out.println(age);      //20
            System.out.println(country);    //中国
        }
    }
}

package com.zhang.oop.demo03clsaa;
public class Applacation {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();   // Outer.Inner inner = new Outer().new Inner();[一步到位]
        inner.show();
    }
}

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

成员内部类不能定义静态成员，但是可以定义静态常量：private static final String name = "李四";

2.静态内部类

package com.zhang.oop.demo03clsaa;

public class Outer {
    private String name = "张三";
    private  int age = 20;
    public void shou(){
        System.out.println("suogi");
    }
    static class Inner{
        Outer outer = new Outer();   //在静态内部类里创建外部类对象
        private String country = "中国";
        private String name = "李四";
        public void show(){
            System.out.println(outer.name); //调用外部类对象属性
            System.out.println(name);
            System.out.println(country);
        }
    }
}

package com.zhang.oop.demo03clsaa;
public class Applacation {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = new Outer.Inner(); // 直接创建内部类对象
        outer.shou(); //常规的  创建外部类对象 调用外部类方法
        inner.show(); // 直接创建内部类对象可调用方法
    }
}

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

3.局部内部类

package com.zhang.oop.demo03clsaa;
public class Outer {
    private String name = "张三";
    public void show(){
        String address = "山西";   //定义局部变量
        class Inner{    //局部内部类：注意不能加任何访问修饰符
            private String phone="123";
            private String email="sd";
            public void show1(){
                System.out.println(Outer.this.name);  //访问外部修饰符
                System.out.println(this.phone); //访问内部修饰符
                System.out.println(address);  //访问局部变量
            }
        }
        Inner inner=new Inner();  //创建局部内部类对象
        inner.show1();
    }
}

package com.zhang.oop.demo03clsaa;
public class Applacation {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }
}

4.匿名内部类

package com.zhang.oop.demo03clsaa;
public interface Usb {
    void Service();
}

package com.zhang.oop.demo03clsaa;
public class Mouse implements Usb {
    @Override
    public void Service() {
        System.out.println("鼠标正常工作");
    }
}

package com.zhang.oop.demo03clsaa;
public class Applacation {
    public static void main(String[] args) {
       Usb usb = new Mouse();
       usb.Service();    //使用多态
  //========================================================
        class Fan implements Usb{
            @Override
            public void Service() {
                System.out.println("风扇正常工作");
            }
        }
        Usb usb1 = new Fan();
        usb1.Service();  //使用局部内部类创建对象调用方法
  //=============================================================
        //使用匿名内部类优化（相当于创建了一个局部内部类）
        Usb usb2 = new Usb(){
            @Override
            public void Service() {
                System.out.println("连接成功");
            }
        };
        usb2.Service();
    }
}

1. 必须继承一个父类或者实现一个接口
2. 定义类，实现类，创建对象的语法合并，只能创建一个该类的对象
3. 优点：减少代码量 缺点：可读性差