二继承与多态——第七节、内部类

作者: 杜艳_66c4 | 来源:发表于2022-05-19 13:52 被阅读0次

二继承与多态——第七节、内部类
面向对象总结
面向对象三大特性
Java内部类.继承.多态
js-继承和闭包
面向对象
Python-面向对象2
iOS开发之一OC语言的特性
程序组第二次作业代码
《Java8学习笔记》读书笔记（七）

如果一个事物的内部包含另一个事物，那就是一个类内部包含另一个类

分类:
1、成员内部类
2、局部内部类，包含匿名内部类

成员内部类的定义格式
修饰符 class 类名称{
修饰符 class 内部类名称{
//..
}
//..
}

注意：内用外，随意使用，外用内，需要内部类对象

1、内部类的概念与分类

成员内部类
局部内部类：包括匿名内部类

2、成员内部类的定义

3、成员内部类的使用

1、间接方式：在外部类的方法中，使用内部类，然后main只是调用外部类的方法
2、直接方法：
类名称对象名 = new 类名称()
外部类名称.内部类名称对象名 = new 外部类名称().new 内部类名称();

主类

package cn.day11.demo03;

/*
如果一个事物的内部包含另一个事物，那就是一个类内部包含另一个类

分类:
1、成员内部类
2、局部内部类，包含匿名内部类

成员内部类的定义格式
修饰符 class 类名称{
    修饰符 class 内部类名称{
     //..
    }
    //..
   }

  注意： 内用外，随意使用，外用内，需要内部类对象
 */
public class Demo01InnerClass {
    public static void main(String[] args) {
        Body body = new Body();
        //间接：通过外部类的对象，调用外部类的方法，里面间接使用内部类Heart
       body.methodBody();
       /*
       结果
       外部类的方法
       心脏跳动
       我叫：null
        */
        System.out.println("==========");
        //直接,按照公式
        Body.Heart bodyheart =  new Body().new Heart();
        bodyheart.beat();
        /*
        心脏跳动
        我叫：null
         */
    }

}

内部类

package cn.day11.demo03;

public class Body { //外部类

    public class Heart{ //成员内部类
        public void beat(){
            System.out.println("心脏跳动");
            System.out.println("我叫：" + name);
        }
    }
    public void methodBody(){
        System.out.println("外部类的方法");
        new Heart().beat();
    }

    public String getName() {
        return name;
    }

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

    private String name;

}

4、内部类的同名变量访问

内部类

package cn.day11.demo03;

public class Outer {
    int num = 10;
    public class Inner{
        int num = 20;
        public void Inner(){
            int num =30;
            System.out.println(this.num); //20
            System.out.println(num);  //30
            System.out.println(Outer.this.num);  //10
        }
    }
}

主方法：

package cn.day11.demo03;

public class Demo02InnerClass {
    public static void main(String[] args) {
        //外部类名称.内部类名称 对象名 =  new 外部类名称().new 内部类名称();
        Outer.Inner inner = new Outer().new Inner();
        inner.Inner();
        /*
        20
        30
        10
         */
    }
}

5、局部内部类的定义

如果一个类是定义在一个方法内部的，就是一个局部内部类，
局部：只有当前所属方法能使用它，出了方法外面就不能用
定义格式：
修饰符 class 外部类名称{
修饰符返回值类型方法名(){
class 局部内部类名称{
// ..
}
}
}

小节权限修饰符：
public > protected > (default) > private
定义一个类的时候，权限修饰符
1、外部类：public protected
2、成员内部类：都行
3、局部内部类：什么都不写
局部内部类

package cn.day11.demo04;

public class Outer {
    public void outer(){
        class Inner{  //局部内部类,只有当前方法outer可以访问
            int num  =10;
            public void Inner(){
                System.out.println(num);  //10
            }
        }
        Inner inner = new Inner();
        inner.Inner();
    }
}

主方法

package cn.day11.demo04;

public class Demomain {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.outer();  //10
    }
}

6、匿名内部类，很重要哦

如果接口的实现类，或者父类的子类，只需要使用唯一一次，就可以省略掉该类的定义，用匿名内部类，
匿名内部类的定义格式：

接口名称对象名 = new 接口名称{
//覆盖重写接口的抽象方法
}
接口

package cn.day11.demo05;

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

实现类：使用匿名内部类，就为了省略这货

package cn.day11.demo05;

public class MyInterfaceImpl implements MyInterface{
    @Override
    public void method() {
        System.out.println("实现类覆盖重写了方法");
    }
}

主方法：

package cn.day11.demo05;

/*
如果接口的实现类，或者父类的子类，只需要使用唯一一次，就可以省略掉该类的定义，用匿名内部类，
匿名内部类的定义格式：

接口名称 对象名 = new 接口名称{
  //覆盖重写接口的抽象方法
}
 */
public class DemoMain {
    public static void main(String[] args) {
        MyInterfaceImpl myInterface = new MyInterfaceImpl();
        MyInterface impl = new MyInterfaceImpl();  //多态的写法，左父右子
        myInterface.method(); //实现类覆盖重写了方法
        impl.method();  //实现类覆盖重写了方法

        //MyInterface myInterface1 = new MyInterface();   错误写法
   // 匿名内部类, 省掉一个实现类的单独定义。简单
        MyInterface myInterface1 = new MyInterface() { //大括号是一个局部内部类， 又没有名字。所以这一块叫匿名内部类，实现了接口
            @Override
            public void method() {
                System.out.println("匿名内部类实现类方法") ;
            }
        };
        myInterface1.method();
    }
}

7、匿名内部类的注意事项

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

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

接口，多个方法

package cn.day11.demo05;

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

主方法

package cn.day11.demo05;

/*
如果接口的实现类，或者父类的子类，只需要使用唯一一次，就可以省略掉该类的定义，用匿名内部类，
匿名内部类的定义格式：

接口名称 对象名 = new 接口名称{
  //覆盖重写接口的抽象方法
}
 */
public class DemoMain {
    public static void main(String[] args) {
        MyInterfaceImpl myInterface = new MyInterfaceImpl();
        MyInterface impl = new MyInterfaceImpl();  //多态的写法，左父右子
        myInterface.method(); //实现类覆盖重写了方法
        impl.method();  //实现类覆盖重写了方法

        //MyInterface myInterface1 = new MyInterface();   错误写法
   // 匿名内部类, 省掉一个实现类的单独定义。简单
        MyInterface objA = new MyInterface() { //大括号是一个局部内部类， 又没有名字。所以这一块叫匿名内部类，实现了接口
            @Override
            public void method() {
                System.out.println("匿名内部类实现类方法111-A") ;
            }

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法222-A");
            }
        };
        objA.method(); //匿名内部类实现类方法111-A
        objA.method2(); //匿名内部类实现类方法222-A

        //使用了匿名内部类，而且也省略了对象名称，也是匿名对象
        new MyInterface() { //大括号是一个局部内部类， 又没有名字。所以这一块叫匿名内部类，实现了接口
            @Override
            public void method() {
                System.out.println("匿名内部类实现类方法111-B") ;
            }

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法222-B");
            }
        }.method();  //匿名内部类实现类方法111-B
    }
}