内部类

* 内部类的是五大成分之一：成员变量，方法，构造器，代码块，内部类
*
* 什么是内部类：
*      定义在一个类里面的类就是内部类
* 内部类的作用;
*      可以提供更好的封装性，内部类右更多权限修饰符，封装类有更多的控制
*      可以体现出组件的思想，汽车是一个类，发动机是汽车的内部类，不能暴漏在外面。就用封*        装起来
* 内部类的分类
*      1，静态内部类(了解)
*      2，实例内部类(成员内部类)
*      3，局部内部类
*      4，匿名内部类

 1，静态内部类
*      什么是静态内部类：
*          有static修饰属于外部类本身，会加载一次
*      静态内部类中的成分
*          类的成分它都有，静态内部类属于与外部类本身，只会加载一次
*          所以它的特点与外部类是完全一样的，只是外置在别人里面
*
*          外部类=寄主
*          内部类=寄生
*
*      静态内部类的访问格式：
*          外部类名称。内部类名称
*
*      静态内部类创建对象的格式：
*          外部类名称.内部类名称  对象名称 = new 外部类名称.内部类构造器
*
*      静态内部类的访问扩展：
*          态内部类中是否可以直接访问外部类的静态成员静  ~可以，外部静态成员只有一份，可以被共享
*          静态内部类中是否可以直接访问外部类的实例成员  ~不可用，外部类的是成员，必须用外部类对象访问

public class DemoInnerClass {
    public static void main(String[] args) {
        //,1外部类名称.内部类名称  对象名称 = new 外部类名称.内部类构造器
        OutterClass.Inner inter = new OutterClass.Inner();
        inter.setName("二狗");
    }
}

class OutterClass{
    public static int age1 = 3;
    private double salary = 3;
    
    //1,静态内部类：有static修饰，属于外部类本身，只会加载一次
    public static class Inner{
        public String name = "王二";
        private int age = 3;
    
        public void show(){
            System.out.println(age1);//态内部类中可以直接访问外部类的静态成员
            //System.out.println(salary);静态内部类中不可以直接访问外部类的实例成员
            //可以间接访问
            OutterClass outterClass = new OutterClass();
            System.out.println(outterClass.salary);
        }
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
}
    

 2，实例内部类(成员内部类)
*      什么是实例内部类
*          无static修饰的内部类，属于外部类的每个对象，跟着对象一起加载
*      实力内部类的成分
*          实力内部类中不能定义静态成员，其他1都可以定义
*          可以定义常量
*      实例内部类的访问格式
*          外部类.内部类名称 对象名称 =  new 外部构造器.new 内部构造器
*       扩展：
*          实例内部类中可以访问外部类的静态成员 ~外部类的静态成员可以被共享
*          实力内部类可以访问外部类的实例成员   ~实例内部类属于外部类对象，可以直接访问当前实例成员
*      小结;
*          实例内部类属于外部类对象，需要用外部类对象一起加载
*          实例内部类可以访问外部类的全部成员

public class DemoInnerClass {
    public static void main(String[] args) {
        //2,外部类.内部类名称 对象名称 =  new 外部构造器.new 内部构造器
        OutterClass.Inner1 inner1 = new OutterClass().new Inner1();
    }
}

//2,实例内部类，无static修饰，属于外部类的对象
    public class Inner1{
        private String name;
        
        //public static String name;属于类不属于对象
        //public static void test(){}
        public void test(){
            System.out.println("实例内部类");
            System.out.println(salary);// 实例内部类中可以访问外部类的静态成员
            System.out.println(age1);//实力内部类可以访问外部类的实例成员
           
        }
    }

3，局部内部类（几乎不用）
*      定义在方法中，在构造器中，代码块中，for循环中定义的内部类
*      局部内部类中的成分特点
*         只能定义实例成员，不能定义静态成员
*          可以定义常量的

//3，局部内部类（几乎不用）
class Inner2{
            static {
            abstract class A{
                public String name = "二狗";
                //public static String name;不能定义静态成员
            }
        }
   
    
    public static void test(){
        System.out.println("test");
    }
}

 4，匿名内部类
*      什么是匿名内部类
*          就是一个没有名字的内部类
*          匿名捏不累目的就是为了：简化代码，也是开发中常用的形式
*      匿名内部类格式
*          new 类名/抽象类/接口(无参){
*              方法重写
*          }
*      匿名内部类的特点
*          1，匿名内部类是一个没有名字的内部类
*          2，匿名内部类一旦写出来，就会立即创建一个匿名内部类的对象返回
*          3，匿名内部类的对象的类型相当于当前new的哪个类型的子类类型

public class DemoInnerClass {
    public static void main(String[] args) {
         //4，匿名内部类
        Animal animal = new Animal() {//匿名内部类，相当于class Cat{}
            @Override
            public void run() {
                System.out.println("猫叫");
            }
        };
        
        Swim sw = new Swim() {
            @Override
            public void Swimming() {
                System.out.println("游泳");
            }
        };
        go(sw);
        
        go(new Swim() {//简化
            @Override
            public void Swimming() {
        
            }
        });
    }

     public static void go(Swim s){
        System.out.println("开始游泳");
        System.out.println("游泳");
        System.out.println("结束游泳");
    }
}


//4，匿名内部类
abstract class Animal{
    public abstract void run();
    
    public void go(Animal an){
        System.out.println("开始跑");
        System.out.println("跑");
        System.out.println("结束跑");
    }
}

interface Swim{
    void Swimming();
}