04.继承与多态——11——final、权限、内部类、引用类型

考点

1. 描述final修饰的类的特点
2. 描述final修饰的方法的特点
3. 能够说出权限修饰符作用范围
4. 说出内部类的概念
5. 能够理解引用类型作为成员变量
6. 能够理解引用类型作为方法参数
7. 能够理解引用类型作为方法返回值类型

一、final关键字

final关键字代表最终、不可改变的。
常见四种用法：

1. 可以用来修饰一个类
          格式：
                 public final class 类名称 {
                         // …
                 }
          含义：当前这个类不能有任何的子类。（太监类）
          注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没儿子。）
2. 可以用来修饰一个方法
          当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
          格式：
                 修饰符 final 返回值类型 方法名称(参数列表) {
                         // 方法体
                 }
          注意事项：
                 对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。
3. 还可以用来修饰一个局部变量
          一旦使用final用来修饰局部变量，那么这个变量就不能进行更改
                 对于基本类型来说，不可变说的是变量当中的数据不可改变
                 对于引用类型来说，不可变说的是变量当中的地址值不可改变
4. 还可以用来修饰一个成员变量
          对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。
                 由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
                 对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。
                 必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。

二、权限

Java中有四种权限修饰符：
						 public  >   protected   >   (default)   >   private
同一个类（我自己）           YES         YES             YES             YES
同一个包（我邻居）           YES         YES             YES             NO
不同包子类（我儿子）         YES         YES             NO              NO
不同包非子类（陌生人）        YES         NO              NO              NO

三、内部类

	如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。
	例如：身体和心脏的关系。又如：汽车和发动机的关系。

分类：

1. 成员内部类
2. 局部内部类（包含匿名内部类）

3.1 成员内部类

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

注意：内用外，随意访问；外用内，需要内部类对象。

3.1.1 使用成员内部类的两种方式

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

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

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

3.2 局部内部类

局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效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);
            }
        }
        Inner inner = new Inner();
        inner.methodInner();    
    }
}

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

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

小节一下类的权限修饰符：
public > protected > (default) > private
定义一个类的时候，权限修饰符规则：

1. 外部类：public / (default)
2. 成员内部类：public / protected / (default) / private
3. 局部内部类：什么都不能写

3.3 匿名内部类

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

匿名内部类的定义格式：
	父类名或者接口名 对象名 = new 父类名或者接口名() {
		// 覆盖重写所有抽象方法
	};
1.等号右边:是匿名内部类，定义并创建该接口的子类对象
2.等号左边:是多态赋值,接口类型引用指向子类对象

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

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(); 
	} 
}

对格式“new 接口名称() {…}”进行解析：

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

另外还要注意几点问题：

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

四、引用类型

4.1 class作为成员变量

类作为成员变量时，对它进行赋值的操作，实际上，是赋给它该类的一个对象。

class Role { 
	int id； 
	int blood； 
	String name； 
	// 添加武器属性 
	Weapon wp； 
	// 添加盔甲属性 
	Armour ar；
	// 提供get/set方法 
	public Weapon getWp() { return wp; }
	public void setWeapon(Weapon wp) { this.wp = wp; }
	...
}

4.2 interface作为成员变量

我们使用一个接口，作为成员变量，以便随时更换技能，这样的设计更为灵活，增强了程序的扩展性。
接口作为成员变量时，对它进行赋值的操作，实际上，是赋给它该接口的一个子类对象。

public class Test { 
	public static void main(String[] args) { 
		// 创建游戏角色 
		Role role = new Role(); 
		// 设置角色法术技能 
		role.setFaShuSkill(new FaShuSkill() { 
				@Override
			public void faShuAttack() { 
				System.out.println("纵横天下"); 
			} 
		}); 
		// 发动法术攻击 
		role.faShuSkillAttack(); 
		// 更换技能 
		role.setFaShuSkill(new FaShuSkill() {
			@Override 
			public void faShuAttack() { 
				System.out.println("逆转乾坤"); 
			} 
		}); 
		// 发动法术攻击 
		role.faShuSkillAttack(); 
	} 
}

4.3 interface作为方法参数和返回值类型

接口作为参数时，传递它的子类对象。
接口作为返回值类型时，返回它的子类对象。

public class Test { 
	public static void main(String[] args) { 
		// 创建ArrayList集合,并添加数字 
		ArrayList<Integer> srcList = new ArrayList<>(); 
		for (int i = 0; i < 10; i++) { 
			srcList.add(i); 
		}
		/*获取偶数集合 
		因为getEvenNum方法的参数是List,而ArrayList是List的子类, 
		所以srcList可以传递 */
		List list = getEvenNum(srcList); 
		System.out.println(list); 
	} 
	public static List<Integer> getEvenNum(List<Integer> list) { 
		// 创建保存偶数的集合 
		ArrayList<Integer> evenList = new ArrayList<>(); 
		// 遍历集合list,判断元素为偶数,就添加到evenList中 
		for (int i = 0; i < list.size(); i++) { 
			Integer integer = list.get(i); 
			if (integer % 2 == 0) { 
				evenList.add(integer); 
			} 
		}
		/*返回偶数集合
		因为getEvenNum方法的返回值类型是List,而ArrayList是List的子类, 
		所以evenList可以返回 */
		return evenList; 
	}
}

五、jshell

	/exit          退出

六、编译器的两点优化