Java学习 第十三天

第一章 权限修饰符

1.1 概述

Java当中提供了四种权限修饰符，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限。

• public：公共的
• protected：受保护的
• (default)：默认的,意思是什么都不写，不是默认方法里的关键字default
• private：私有的

1.2 不同权限的访问能力

\	public	protected	(default)	private
同一个类(我自己)	yes	yes	yes	yes
同一个包中(我邻居)	yes	yes	yes	no
不同包的子类(我儿子)	yes	yes	no	no
不同包的非子类(陌生人)	yes	no	no	no

注意： 包和它的子包并不是同一个包，只要不是同一个包，在引用其中的类时候，就必须写import导入语句。

第二章 内部类

2.1 概述

将一个类A定义在另一个类B里面，里面的那个类A就称之为内部类，B则称为外部类。

分类：
1.成员内部类
2.普通局部内部类
3.匿名局部内部类

2.2 成员内部类

定义在类中方法外的类就是成员内部类

成员内部类的定义格式：

修饰符 class  外部类名称{
	修饰符 class 内部类名称{
		//	...
	}
	//	...
}

访问规则：
内部类使用外部类时，无论外部类使用什么修饰符，都可以随意访问。
外部类访问内部类时，必须有内部类对象才可以。

访问方式：
如何使用成员内部类？有两种方式：
1.在外部类的方法当中，使用内部类；然后main只是调用外部类的方法。【间接方式】
2.直接方式(直接创建内部类对象)：公式：
外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称()

代码演示：

//	定义外部类Body
public class Body { //  外部类
    public class Heart{ //  成员外部类

        //  内部类的方法
        public void beat(){
            System.out.println("心脏跳动，蹦蹦蹦！");
            System.out.println("我叫：" + name);   //  正确写法！
        }

    }

    //  外部类的成员变量
    private String name;

    //  外部类的方法
    public void methodBody(){
        System.out.println("外部类的方法");
        new Heart().beat();	//	这是匿名对象的调用格式
    }

    public String getName() {
        return name;
    }

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

//	定义测试类
public class Demo01InnerClass {

    public static void main(String[] args) {
        Body body = new Body();
        //  通过外部类的对象，调用外部类的方法，里面间接使用内部类Heart
        body.methodBody();
        System.out.println("====================");

        //  按照公式写：
        Body.Heart heart = new Body().new Heart();
        heart.beat();
    }
}

如果出现了成员内部类和外部类成员变量重名现象，那么格式是：外部类名称.this.外部类成员变量名

public class Outer {
    int num = 10;   //  外部类的成员变量
    public void method(){
        System.out.println("外部方法");
    }

    public class Inner{
        int num = 20;   //  内部类的成员变量

        public void methodInner(){
            int num = 30;   //  内部类的局部变量
            System.out.println(num);    //  局部变量，就近原则
            System.out.println(this.num);   //  内部类的成员变量
            System.out.println(Outer.this.num); //  外部类的成员变量
        }
        public void method(){
            System.out.println("内部方法");
        }
    }
}

2.3 普通局部内部类

局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是 【有效final的】
备注：
从Java 8+开始，只要局部变量事实上没有进行改变，那么final关键字可以省略。
原因：
1.new出来的对象在堆内存当中。
2.但是局部变量是跟着方法走的，在栈内存当中。
3.方法运行结束之后，立刻出栈，局部变量就会立刻消失。
4.new出来的对象会在堆内存当中持续存在，直到垃圾回收为止。

注意： 当局部内部类和外部类变量重名时，会发生覆盖现象，将无法在局部内部类访问到外部类的同名变量

代码演示：

public class MyOuter {
    public void methodOuter(){
        final int num = 10;   //  所在方法的局部变量

        class MyInner{
        	//  此处定义num和上面的局部变量重名
        	//	相当于num不再指向10，重新指向了20，发生了覆盖现象
            //  无法再访问到10
            //  Java当中不允许发生方法的嵌套
        	int num = 20;
            public void methodInner(){
                System.out.println(num);	//	20
            }
        }
    }
}

2.4 外内部类的权限修饰符规则

public > protected > (default) > private
定义一个类的时候，权限修饰符规则：
1.外部类只能是这两种： public / (default)
2.成员内部类: public / protected / (default) / private
3.局部内部类必须无修饰符; 什么都不能写（这并不是(default)修饰符的意思）

2.5 匿名内部类(局部内部类的一种)【重点】

2.5.1 概述

是内部类的简化写法。它的本质是一个带具体实现的，父类或者父接口的,匿名的子类对象。
匿名内部类：匿名内部类也是局部内部类，这意味着匿名内部类是出现在一个方法的内部的，如果它要访问这个方法的参数或者方法中定义的变量，则这些参数和变量必须被修饰为final。

2.5.2 使用格式

匿名内部类的定义格式：

接口名称 对象名 = new 接口名称(){
    //  覆盖重写所有的抽象方法
};

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

注意： 匿名内部类是指匿名了实现类的名称，而不是匿名了实现类对象的名称

2.5.3 使用演示

//	定义接口MyInterface
public interface MyInterface {
    void method1();   //  抽象方法,这里省略了public abstract
    void method2();
}


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

    @Override
    public void method2() {

    }
}


//	定义测试类
public class DemoMain {
    public static void main(String[] args) {
        //  多态写法
        //  这里只用了一次实现类MyInterfaceImpl创建对象，但是需要创建一个MyInterfaceImpl类作为实现类，太过麻烦，因此可以使用匿名内部类写法
//        MyInterface obj = new MyInterfaceImpl();
//        obj.method();

//        MyInterface some = new MyInterface();   //  错误写法

        //  使用匿名内部类,但不是匿名对象
        MyInterface objA = new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！111-A");
            }

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

        //  不仅使用了匿名内部类，而且省略了对象名称，也是匿名对象
        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！111-B");
            }

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法！222-B");
            }
        }.method1();
        //  因为匿名对象无法调用第二次方法，所以需要再创建一个匿名内部类的匿名对象
        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！111-B");
            }

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

注意： 要注意上述代码当中匿名对象和匿名内部类的结合使用情况