java学习笔记——权限修饰符、内部类

2.1 概述

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

·public：公共的
·protected：受保护的
·default：默认的
·private：私有的

2.2 不同权限的访问能力

可见，public具有最大权限。private则是最小权限。

编写代码时，如果没有特殊的考虑，建议这样使用权限：
1、成员变量使用private ，隐藏细节
2、构造方法使用public，方便创建对象。
3、成员方法使用public，方便调用方法。

小贴士：不加权限修饰符，其访问能力与default修饰符相同。

第三章

1.1 概述

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

成员内部类
·成员内部类：定义在类中方法外的类。

定义格式：

class 外部类 {
	class 内部类{
	}
}

在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。比如：汽车类Car中包含发动机类Engine，这时，Engine就可以使用内部类来描述，定义在成员位置。

代码举例：

class Car { //外部类
	class Engine { //内部类
	}
}

访问特点
1、内部类可以直接访问外部类的成员，包括私有成员
2、外部类要访问内部类的成员，必须要建立内部类的对象

创建内部类对象格式：

外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；

访问演示，代码如下：
定义类：

package demo4;

public class Person {
    private boolean live =true;
    class Heart{
        public void jump(){
            //直接访问外部类成员
            if(live){
                System.out.println("心脏在跳动");
            }
            else {
                System.out.println("心脏不跳了");
            }
        }
    }
    
    public boolean isLive(){
        return live;
    }
    public void setLive(boolean live){
        this.live=live;
    }
}

定义测试类：

package demo4;

public class Text {
    public static void main(String[] args) {
        //创建外部类对象
        Person p=new Person();
        //创建内部类对象
        Person.Heart heart=p.new Heart();
        
        //调用内部类方法
        heart.jump();
        //调用外部类方法
        p.setLive(false);
        //调用内部类方法
        heart.jump();
    }
}

输出结果：

内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$ 符号 。
比如，Person$Heart.class

1.2 匿名内部类【重点】

匿名内部类：是内部类的简化写法。它的本质是一个带具体实现的父类或者父接口的匿名的子对象。开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口的时候，得做如下操作：
1、定义子类
2、重写接口中的方法
3、创建子类对象
4、调用重写后的方法

我们的目的，是为了调用方法，那么能不能简化一下，将四步合成一步。匿名内部类就是做这样的快捷方式。

前提
匿名内部类必须继承一个父类或者实现一个父类接口。

格式

new 父类名或者接口名(){
    // 方法重写
    @Override
    public void method() {
    // 执行语句
        }
};

使用方式
以接口为例，匿名内部类的使用，代码如下：
定义接口：

public abstract class FlyAble{
	public abstract void fly();
}

创建匿名内部类，并调用：

public class InnerDemo {
    public static void main(String[] args) {
/*
1.等号右边:是匿名内部类，定义并创建该接口的子类对象
2.等号左边:是多态赋值,接口类型引用指向子类对象
*/
        FlyAble f = new FlyAble(){
            public void fly() {
                System.out.println("我飞了~~~");
            }
        };
//调用 fly方法,执行重写后的方法
        f.fly();
    }
}

通常在方法的形式参数时接口或者抽象类时，也可以将匿名内部类作为参数传递。代码如下：

public class InnerDemo2 {
    public static void main(String[] args) {
/*
1.等号右边:定义并创建该接口的子类对象
2.等号左边:是多态,接口类型引用指向子类对象
*/
        FlyAble f = new FlyAble(){
            public void fly() {
                System.out.println("我飞了~~~");
            }
        };
// 将f传递给showFly方法中
        showFly(f);
    }
    public static void showFly(FlyAble f) {
        f.fly();
    }
}

以上两步，也可以简化为一步，代码如下：

public class InnerDemo3 {
    public static void main(String[] args) {
        /*
        创建匿名内部类，直接传递给showFly(FlyAble f)
        * */
        showFly(new FlyAble(){
            public void fly(){
                System.out.println("我飞了~~");
            }
        });
    }
    public static void showFly(FlyAble f){
        f.fly();
    }
}