Java_内部类

        内部类表示的事物是外部类的一部分，内部类单独出现没有任何意义

        如汽车的发动机，人的心脏等

---

        分为成员内部类、静态内部类（也是成员内部类一种）、布局内部类、匿名内部类

        内部类可以直接访问外部类的成员，包括私有

        外部类要访问内部类的成员，必须创建对象

成员内部类：

        是写在成员位置的，属于外部类的成员

        可以被一些修饰符所修饰，如：private、默认、public、protect、static等        

        成员内部类里，jkd16之前不能定义静态变量，jdk16开始才可以定义静态变量

获取成员内部类对象：

1、非私有修饰时：

                外部类名.内部类名 对象名 = new 外部类对象.  new 内部类对象;

2、被private修饰时：

                在外部类编写方法，对外提供内部类对象

外部类成员变量和内部类成员变量重名时：

System.out.println(Outer.this.变量名) ;

//Demo类

package com.hb2.内部类_成员内部类;

import com.hb2.抽象类作为形参和返回值.Operatr;

//内部类使用：外部类名.内部类名 对象名 = new 外部类对象.  new 内部类对象
public class Demo {
    public static void main(String[] args) {
        Outer.Inner o = new Outer().new Inner();
        o.show();

        Outer o1 = new Outer();
        o1.method();
    }
}


//Outer类

package com.hb2.内部类_成员内部类;
/*

    内部类格式：
        public class 类名{
            修饰符 class 类名{

            }
        }

    内部类访问特点：
        内部类可以直接访问外部类的成员，包括私有
        外部类要访问内部类的成员，必须创建对象
 */

public class Outer {
    private int num= 10;

    public class Inner{
        public void show(){
            System.out.println(num);
        }
    }

    private class Inner2{
        public void show(){
            System.out.println(num);
        }
    }

    public void method(){
        Inner2 i = new Inner2();
        i.show();
    }
}

静态内部类：

创建静态内部类对象方式：

外部类名.内部类名 对象名 = new 外部类对象.  内部类对象;

调用静态内部类方法：

非静态方法：

                先创建对象，用对象调用

静态方法：

                外部类名.内部类名.方法名();

局部内部类： 

        1、将内部类定义在方法里就叫局部内部类，类似于方法里面的局部变量

        2、外界无法直接使用，需要在方法内部创建对象并使用

        3、该类可以直接访问外部类的成员，也可以访问方法内的局部变量

// Demo类

hb2.内部类_局部内部类;

public class Demo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}


//Outer类

package com.hb2.内部类_局部内部类;
/*
    局部内部类是在方法中定义的类，所以外界是无法直接使用的，需要在
    方法内部创建对象并使用该类可以直接访问外部类的成员，也可以访问
    方法内的局部变量
 */
public class Outer {
    private int num= 10;

    public void method(){
        class Inner{
            public void show(){
                System.out.println(num);
             }
        }
        Inner i = new Inner();
        i.show();
    }

}

匿名内部类： 

        隐藏了名字的内部类，可以卸载成员位置，也可以写在局部位置

格式：

  new 类型或者接口名(){
            重写方法
       };

        包含了继承或实现，方法重写，创建对象。

        整体就是一个类的子类对象或接口的实现类对象

使用场景：

        当方法的参数是接口或者类时

        以接口为例，可以传递这个接口的实现类对象

        如果实现类只要使用一次，就可以用匿名内部类简化代码

//Demo类

package com.hb2.内部类_匿名_局部内部类;

public class Demo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}


//Outer类
package com.hb2.内部类_匿名_局部内部类;
//前提：存在一个类或者接口，这里的类可以是具体也可以是抽象类
//本质：是一个继承了该类或者实现了该接口的子类匿名对象
/*
格式！！！：

       new 类型或者接口名(){
            重写方法
       };

 */
public class Outer {
    public void method(){
        //本质：是一个继承了该类或者实现了该接口的子类匿名对象
//        new inter(){
//            @Override
//            public void show() {
//                System.out.println("匿名内部类");
//            }
//        };

//        new inter(){
            //            @Override
//            public void show() {
//                System.out.println("匿名内部类");
//            }
//        }.show();
        //以接口名声明变量，是接口的多态
         inter i  = new inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };

         i.show();


    }
}


//inter接口

package com.hb2.内部类_匿名_局部内部类;

public interface inter {
    void show();
}

匿名局部内部类的运用： 

//Demo类

package com.hb2.内部类_应用_匿名_局部内部类;

public class Demo {
    public static void main(String[] args) {
        jumpoperate j = new jumpoperate();

        jump c = new Cat();
        j.method(c);

        j.method(new jump() {
            @Override
            public void jump() {
                System.out.println("傻逼可以走了");
            }
        });

        j.method(new jump() {
            @Override
            public void jump() {
                System.out.println("你说这呢？");
            }
        });
    }
}

//jump接口

package com.hb2.内部类_应用_匿名_局部内部类;

public interface jump {
    void jump();
}


//jumpoperate类

package com.hb2.内部类_应用_匿名_局部内部类;

public class jumpoperate {
    public void method(jump j){
        j.jump();
    }

}


//Cat类

package com.hb2.内部类_应用_匿名_局部内部类;

public class Cat implements jump{
    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}