2021-03-10：java第十三天：成员内部类、匿名内部类和匿名对象、接口的使用、JShell

1.成员内部类的介绍及使用：

package Day_13.demo01;
//ctrl+shift+F9 = recompile body.java
public class Body { //外部类 Body.class
    public class Heart{ //成员内部类, Body$Heart.class
        //内部类的方法
        public void beat(){
            System.out.println("心脏跳动，蹦蹦蹦");
            System.out.println("我叫："+name);
        }
    }
    //外部类的成员变量
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    //外部类的方法
    public void methodBody(){
        System.out.println("外部类的方法");
        //Heart heart = new Heart();
        //heart.beat();
        new Heart().beat();
    }
}


package Day_13.demo01;
/*
如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类
身体和心脏的关系，又如汽车和发动机的关系

分类：
1.成员内部类
2.局部内部类(包含匿名内部类)

成员内部类的定义格式
修饰符 class 外部类名称{
    修饰符 class 内部类名称{
    }
}
注意：内用外，可以随意访问;外用内，需要内部类对象

如何使用成员内部类？有两种方式：
1.间接方式：在外部类的方法当中，使用内部类;然后main只是调用外部类的方法
2.直接方式：公式：
类名称 对象名 = new 类名称();
外部类名称.内部类名称 对象名= new 外部类名称().new 内部类名称();
 */
public class demo01InnerClass {
    public static void main(String[] args) {
        Body body = new Body();//外部类的对象
        //通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heart
        body.methodBody();
        //按照公式写：
        Body.Heart heart = new Body().new Heart();
        heart.beat();
    }
}

2.内部类的重名变量如何访问

 

package Day_13.demo01;
//如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名
public class Outer {
    int num = 10; //外部类的成员变量
    public class Inner /*extends Object*/{
        int num = 20; //内部类的成员变量
        public void methodInner(){
            int num = 30;  //内部类方法的局部变量
            System.out.println(num);//10 局部变量，就近原则
            System.out.println(this.num); //20 内部类的成员变量
            System.out.println(Outer.this.num);//30 外部类的成员变量
        }
    }
}


package Day_13.demo01;

public class demo02InnerClass {
    public static void main(String[] args) {
        // 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
        Outer.Inner obj = new Outer().new Inner();
        obj.methodInner();
    }
}

 

3.局部内部类定义

package Day_13.demo02;
/*
如果一个类是定义在一个方法内部的，那么这就是一个局部内部类
“局部”，只有当前所属的方法才能使用它，出了这个方法外面就不能用了

定义格式：
修饰符 class 外部类名称{
    修饰符 返回值类型 外部类方法名称(参数列表){
        class 局部内部类名称 {
            //..
        }
    }
}

小结一下类的权限修饰符：
public > protected > (default) > private
1.定义一个类的时候，权限修饰符规则
1.外部类 public / (default)
2.成员内部类 public / protected / (default) /private
3.局部内部类 什么都不能写
 */
public class Outer {
    public void methodOuter(){
        class Inner { //局部内部类
            int num = 10;
            public void methodInner(){
                System.out.println(num);
            }
        }
        Inner inner = new Inner();
        inner.methodInner();
    }
}


package Day_13.demo02;

public class demoMain {
    public static void main(String[] args) {
        Outer obj = new Outer();
        obj.methodOuter();
    }
}


package Day_13.demo02;
/*
局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是有效final的（只能赋值一次）
备注：从Java 8开始，只要局部变量事实不变，那么final关键字可以省略。

原因：
1.new出来的对象在堆内存当中
2.局部变量是跟着方法走的，在栈内存当中
3.方法运行结束之后，立刻出栈，局部变量就会立刻消失
4.new 出来的对象会在堆当中持续存在，直到垃圾回收消失
 */
public class MyOuter {
    public void methodOuter(){
        int num = 10; //所在方法的局部变量

        class MyInner {
            public void methodInner(){
                System.out.println(num);
            }
        }
    }
}

4.匿名内部类和匿名对象

package Day_13.demo03;

public interface MyInterface {
    void method1(); //抽象方法
    void method2();
}

package Day_13.demo03;

public class MyInterfaceImpl implements MyInterface{

    @Override
    public void method1() {
        System.out.println("实现类覆盖重写了方法111");
    }

    @Override
    public void method2() {
        System.out.println("实现类覆盖重写了方法222");
    }
}



package Day_13.demo03;
/*
如果接口的实现类，或者是父类的子类，只需要使用唯一的一次
那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】

匿名内部类的定义格式：
接口名称 对象名= new 接口名称(){
    //覆盖重写所有抽象方法
};

对格式进行解析”new 接口名称(){...}“进行解析：
1.new代表创建对象的动作
2.接口名称就是匿名内部类需要实现哪个接口
3.{...}这才是匿名内部类的内容

注意的内容：
1.匿名内部类，在【创建对象】的时候只能使用唯一一次
如果希望多次创建对象，而且类的内容一样的话，只能使用单独的实现类
2.匿名对象，在【调用方法】的时候，只能调用唯一一次
如果希望同一个对象调用多次方法，必须给对象起个名字
3.匿名内部类是省略了【实现类/子类名称】，但匿名对象是省略了【对象名称】
强调：匿名内部类和匿名对象不是一回事！！！
 */

public class demoMain {
    public static void main(String[] args) {
        //多态
        MyInterface impl = new MyInterfaceImpl();
        impl.method1();
        impl.method2();
        //MyInterface some = new MyInterface();错误写法
        //使用匿名内部类,但不是匿名对象，对象名称就叫objA
        MyInterface objA = new MyInterface() { //没有名称，匿名 局部内部类
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法111A！");
            }
            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法222A！");
            }
        };
        objA.method1(); //匿名内部类实现了方法！
        objA.method2();
        //使用了匿名内部类，而且是匿名对象
        new MyInterface() { //没有名称，匿名 局部内部类
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！111B");
            }
            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法！222B");
            }
        }.method1(); //匿名内部类实现了方法！
        //objB.method2();因为匿名对象无法调用第二次方法，所以需要再创建一个匿名内部类的匿名对象
        new MyInterface() { //没有名称，匿名 局部内部类
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！111B");
            }
            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法！222B");
            }
        }.method2();

    }
}

 

5.类作为成员变量类型

package Day_13.demo04;
//游戏当中的英雄角色类
public class Hero {
    private String name;//英雄名字
    private Weapon weapon; //英雄武器
    private int age; //英雄年龄

    public void attack(){
        System.out.println("年龄为"+age+"的"+name+"用"+weapon.getCode()+"攻击敌方");
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Weapon getWeapon() {
        return weapon;
    }

    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Hero(String name, Weapon weapon, int age) {
        this.name = name;
        this.weapon = weapon;
        this.age = age;
    }

    public Hero() {
    }
}


package Day_13.demo04;

public class Weapon {
    private String code;//武器的代号

    public Weapon(String code) {
        this.code = code;
    }

    public Weapon() {
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}

package Day_13.demo04;

public class demoMain {
    public static void main(String[] args) {
        //创建英雄角色
        Hero hero = new Hero();
        hero.setName("盖伦");
        hero.setAge(20);
        //创建一个武器对象
        Weapon weapon = new Weapon("多兰剑");
        //为英雄配备武器
        hero.setWeapon(weapon);
        //年龄为20的盖伦用多兰剑攻击敌方
        hero.attack();
    }
}

6.接口作为成员变量类型

package Day_13.demo05;

public class Hero {
    private String name;
    private Skill skill;

    public String getName() {
        return name;
    }
    public void attack(){
        System.out.println("我叫"+name+",开始释放技能：");
        skill.use();
        System.out.println("释放技能完成");
    }
    public void setName(String name) {
        this.name = name;
    }

    public Skill getSkill() {
        return skill;
    }

    public void setSkill(Skill skill) {
        this.skill = skill;
    }

    public Hero(String name, Skill skill) {
        this.name = name;
        this.skill = skill;
    }

    public Hero() {
    }
}


package Day_13.demo05;

public interface Skill {
    void use();//抽象方法
}

package Day_13.demo05;

public class SkillImpl implements Skill{
    @Override
    public void use() {
        System.out.println("Biu~Biu~");
    }
}


package Day_13.demo05;

public class demoGame {
    public static void main(String[] args) {
        Hero hero = new Hero();
        hero.setName("艾希");//设置英雄名称
        //设置英雄技能
        //hero.setSkill(new SkillImpl());//使用单独定义的实现类

        //可以使用匿名内部类
        Skill skill =new Skill() {
            @Override
            public void use() {
                System.out.println("pia~pia~");
            }
        };

        //可以使用匿名对象和匿名实现类（匿名内部类）
        hero.setSkill(new Skill() {
            @Override
            public void use() {
                System.out.println("Da~Da");
            }
        });
        hero.attack();
    }
}

7.接口作为方法参数或者返回值

package Day_13.demo05;

import java.util.ArrayList;
import java.util.List;
/*
java.util.list正是Arraylist所实现的接口
 */
public class DemoInterface {
    public static void main(String[] args) {
        //左边是接口名称，右边是实现类名称，多态写法
        List list = new ArrayList<>();
        List result = addNames(list);
        for (int i = 0; i < result.size(); i++) {
            System.out.println(result.get(i));
        }
    }
    public static List addNames(List list){
        list.add("迪丽热巴");
        list.add("古力娜扎");
        list.add("马儿扎哈");
        return list;
    }
}

8.发红包案例（略）

9.JShell 的使用

脚本：

退出JShell:     /exit

10.编译器的两点优化

自动补上强转