10—JAVA—类（final、权限、内部类、引用类型）

01final关键字

1.1什么是final关键字

• 概述
  在继承中，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承API中提供的类，改写其内容呢？显然这是不行的。为了避免这种随意改写的情况，Java提供了 final 关键字，用于修饰不可改变内容。
• final： 不可改变。可以用于修饰类、方法和变量。
  类：被修饰的类，不能被继承。
  方法：被修饰的方法，不能被重写。
  变量：被修饰的变量，不能被重新赋值

1.2 使用方式

• 修饰类格式如下：

final class 类名 {
}

查询API发现像 public final class String 、 public final class Math 、 public final class Scanner等，很多我们学习过的类，都是被final修饰的，也就是我们只能使用不能改变

• 修饰方法格式如下：

修饰符 final 返回值类型 方法名(参数列表){
	//方法体
}

重写被 final 修饰的方法，编译时就会报错

• 修饰变量（变量分为基本类型和引用类型）

1. 局部变量——基本类型
   基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。代码如下：

//被final修饰的变量只能赋值一次
public class FinalDemo1 {
	public static void main(String[] args) {
		// 声明变量，使用final修饰
		final int a;
		// 第一次赋值
		a = 10;
		// 第二次赋值
		a = 20; // 报错,不可重新赋值
		
		// 声明变量，直接赋值，使用final修饰
		final int b = 10;
		// 第二次赋值
		b = 20; // 报错,不可重新赋值
	}
}

2. 局部变量——引用类型
   引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的修改，代码如下：

public class finalDemo2{
	//创建一个Cat对象
	final Cat c=new Cat();
	//使用c创建另外一个对象（报错）
	//c=new Cat();
	
	//给对象属性赋值
	c.name="AISMALL";
	//修改属性的值
	c.name="AISMALL_01";
}
//定义个一类
class Cat{
	public String name;
}

3. 成员变量
   成员变量涉及到初始化的问题，初始化方式有两种：
   显示初始化

public class User {
	//直接在定义变量的时候初始化，不可改变
	//所有的User对象公用一个名字：AISMALL
	final String USERNAME = "AISMALL";
	private int age;
}

构造方法初始化

public class User {
	//定义一个使用final修饰的成员变量
	final String USERNAME ;
	private int age;
	//定义一个有参构造方法，可以用来初始化成员变量
	public User(String username, int age) {
		this.USERNAME = username;
		this.age = age;
}
}

02权限修饰符

2.1什么是权限修饰符

• 概述
  在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，
  public：公共的。
  protected：受保护的
  default：默认的
  private：私有的

2.2 不同权限的访问能力

	public	protected	default	private
同一类中	√	√	√	√
同一包中（子类和无关类）	√	√	√
不同包中的子类	√	√
不同包中的无关类	√

• 可见，public具有最大权限。private则是最小权限。
  编写代码时，如果没有特殊的考虑，建议这样使用权限：
  成员变量使用 private ，隐藏细节。
  构造方法使用 public ，方便创建对象。
  成员方法使用 public ，方便调用方法。
• 注意：不加权限修饰符，其访问能力与default修饰符相同

03 内部类

3.1什么是内部类？

• 概述
  将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。
• 成员内部类
  成员内部类 ：定义在类中方法外的类，即一个类是另一个类的成员
  定义格式：

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

在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。比如，省份类（Province）包含城市类（City） ，这时， 城市类就可以使用内部类来描述，定义在成员位置。

class Province { //外部类
	class City { //内部类
	}
}

• 访问特点
  内部类可以直接访问外部类的成员，包括私有成员。（暂时可以把内部类想象成一个成员变量）。
  外部类要访问内部类的成员，必须要建立内部类的对象。
  创建内部类对象格式：

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

内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前会加上外部类的类名和$符号 。

比如：Province$City.class

3.2 匿名内部类【重点】

• 匿名内部类 ：是内部类的简化写法。它的本质是一个带具体实现的 父类或者父接口的匿名的子类对象。
  开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，似乎得做如下几步操作，

1. 定义接口的子类
2. 在子类中重写接口的抽象方法
3. 创建子类对象
4. 调用重写后的方法

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

• 前提
  匿名内部类必须继承一个父类或者实现一个父接口。
• 格式:（以接口为例，类也是一样的）

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

分析：
看似是直接new接口一样，但是后面多了一个大括号

以前是先定义接口
然后定义接口实现类
在接口实现类中重写接口中的抽象方法
然后创建实现类的对象
调用重写的方法

现在是省略了编写实现类的过程，直接在new接口的时候重写接口中的抽象方法.
注意：不能这样直接new接口（接口名称 对象名=new 接口名称();，错误写法）

接口不能直接new，但是可以通过匿名内部类的方式new接口

• 使用方式：（以接口为例）
  定义接口：

//定义一个抽象接口
public abstract interface Animal{
	public abstract void eat();
}

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

public class Test{
	public static void main(String[] args){
		//使用匿名内部类
		/*
		1.等号右边:是匿名内部类，定义并创建该接口的子类对象
		2.等号左边:是多态赋值,接口类型引用指向子类对象
		*/
		Animal a=new Animal(){
			public void eat(){
				System.out.println("动物吃草");
				}
			};
		//调用在匿名内部类中重写的方法
		a.eat();
	}
}

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

//定义一个抽象接口
public abstract interface Animal{
	public abstract void eat();
}

定义测试类：

public class Test{
	public static void main(String[] args){
		//使用匿名内部类
		Animal a=new Animal(){
			public void eat(){
				System.out.println("动物吃草");
				}
			};
		
		//调用showEat方法
		showEat(a);
}
//定义一个方法，形参为接口类型
public void showEat(Animal a){
	a.eat();
 }
}

简化写法(重点)

public class Test{
	public static void mian(String[] args){
		
		//调用souwEat方法
		showEat( new Animal(){
			public void eat(){
				System.out.println("动物吃草");
				}	
			});
		}
		
	//定义一个方法，形参为接口类型
	public void showEat(Animal a){
		a.eat();
	 }
}

04引用类型用法总结

基本类型可以作为成员变量、作为方法的参数、作为方法的返回值，那么当然引用类型也是可以的。

4.1class作为成员变量

在定义一个类Role（游戏角色）时，代码如下：

class Role {
	int id; // 角色id
	int blood; // 生命值
	String name; // 角色名称
}

分析：使用 int 类型表示角色id和生命值（int类型为基本数据类型），使用 String 类型表示姓名（String 是引用数据类型），由于使用的方式类似常量，所以往往忽略了它是引用类型的存在，所以基本类型可以作为成员变量

举个栗子：
第一步：定义一个武器类

public class Weapon {
    String name; // 武器名称
    int hurt; // 伤害值
	//无参构造
    public Weapon(){}
    //提供有参构造用于初始化
    public Weapon(String name,int hurt){
        this.name=name;
        this.hurt=hurt;
    }
    
    //提供set/get方法
     public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }

    public int getHurt() {
        return hurt;
    }

    public void setHurt(int hurt) {
        this.hurt = hurt;
    }
    }

第二步：定义一个装备类

public class Armour {
    String name;// 装备名称
    int protect;// 防御值

    public Armour(){}
    public Armour(String name ,int protect){
        this.name=name;
        this.protect=protect;
    }
    public String getName() {
        return name;
    }

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

    public int getProtect() {
        return protect;
    }

    public void setProtect(int protect) {
        this.protect = protect;
    }
}

第三步：定义一个角色类

public class Role {
    int id; // 角色id
    int blood; // 生命值
    String name; // 角色名称
    // 添加武器属性（武器类作为角色类的成员变量）
    Weapon wp;
    // 添加盔甲属性（盔甲类作为角色类的成员变量）
    Armour ar;

    // 提供get/set方法：注意返回值类型
    public Weapon getWp() {
        return wp;
    }
    public void setWeapon(Weapon wp) {
        this.wp = wp;
    }
    public Armour getArmour() {
        return ar;
    }
    public void setArmour(Armour ar) {
        this.ar = ar;
    }
    // 攻击方法
    public void attack(){
        System.out.println("使用"+ wp.getName() +", 造成"+wp.getHurt()+"点伤害");
    }
    // 穿戴盔甲
    public void wear(){
    // 增加防御,就是增加blood值
        this.blood += ar.getProtect();
        System.out.println("穿上"+ar.getName()+", 生命值增加"+ar.getProtect());
    }
}

第四步：定义测试类

public class Test {

    public static void main(String[] args) {
        // 创建Weapon 对象
        Weapon wp = new Weapon("M416", 999999);
        // 创建Armour 对象
        Armour ar = new Armour("三级甲",10000);
        // 创建Role 对象
        Role r = new Role();
        // 设置武器属性
        r.setWeapon(wp);
        // 设置盔甲属性
        r.setArmour(ar);
        // 攻击
        r.attack();
        // 穿戴盔甲
        r.wear();
        }
    }

第五步：运行结果

使用M416, 造成999999点伤害
穿上三级甲, 生命值增加10000

也可以写在一起，下面是代码：

import java.util.Arrays;

public class Test {

    public static void main(String[] args) {
        // 创建Weapon 对象
        Weapon wp = new Weapon("M416", 999999);
        // 创建Armour 对象
        Armour ar = new Armour("三级甲",10000);
        // 创建Role 对象
        Role r = new Role();
        // 设置武器属性
        r.setWeapon(wp);
        // 设置盔甲属性
        r.setArmour(ar);
        // 攻击
        r.attack();
        // 穿戴盔甲
        r.wear();
        }
    }

//定义武器类
class Weapon {
    String name; // 武器名称
    int hurt; // 伤害值

    public Weapon(){}
    //提供有参构造用于初始化
    public Weapon(String name,int hurt){
        this.name=name;
        this.hurt=hurt;
    }

    public String getName() {
        return name;
    }

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

    public int getHurt() {
        return hurt;
    }

    public void setHurt(int hurt) {
        this.hurt = hurt;
    }
}

//定义装备类
class Armour {
    String name;// 装备名称
    int protect;// 防御值

    public Armour(){}
    public Armour(String name ,int protect){
        this.name=name;
        this.protect=protect;
    }
    public String getName() {
        return name;
    }

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

    public int getProtect() {
        return protect;
    }

    public void setProtect(int protect) {
        this.protect = protect;
    }
}
//定义角色类
class Role {
    int id; // 角色id
    int blood; // 生命值
    String name; // 角色名称
    // 添加武器属性（武器类作为角色类的成员变量）
    Weapon wp;
    // 添加盔甲属性（盔甲类作为角色类的成员变量）
    Armour ar;

    // 提供get/set方法：注意返回值类型
    public Weapon getWp() {
        return wp;
    }
    public void setWeapon(Weapon wp) {
        this.wp = wp;
    }
    public Armour getArmour() {
        return ar;
    }
    public void setArmour(Armour ar) {
        this.ar = ar;
    }
    // 攻击方法
    public void attack(){
        System.out.println("使用"+ wp.getName() +", 造成"+wp.getHurt()+"点伤害");
    }
    // 穿戴盔甲
    public void wear(){
    // 增加防御,就是增加blood值
        this.blood += ar.getProtect();
        System.out.println("穿上"+ar.getName()+", 生命值增加"+ar.getProtect());
    }
}

4.2 interface作为成员变量

• 接口是对方法的封装，例如在游戏当中，如果想扩展游戏角色的技能，可以通过接口来实现。我们在Role 中，可以增加接口作为成员变量，来设置不同的技能。
  第一步：定义一个接口

// 增加角色功能，是角色可以释放法术
public interface FaShuSkill {
	public abstract void faShuAttack();
}

第二步：定义角色类：

//角色类
public class Role {
	//在角色类中添加接口类型的变量
	FaShuSkill fs;
	//定义设置接口变量的方法
	public void setFaShuSkill(FaShuSkill fs) {
		this.fs = fs;		
	} 
	// 定义法术攻击方法
	public void faShuSkillAttack(){
		System.out.print("发动法术攻击:");
		//调用重写的方法
		fs.faShuAttack();
		System.out.println("攻击完毕");
	}	
}

第三步：定义测试类

public class Test{
	public static void main(String[] args){
		//创建角色对象
		Role role=new Role();
		//设置角色法术技能(接口的匿名内部类)
		role.setFaShuSkill(new FaShuSkill(){
			public void faShuAttack(){
				System.out.println("绽放之舞");
				}
		});
		//发动法术攻击
		faShuSkillAttack();
		
		//更换技能
		role.setFaShuSkill(new FaShuSkill(){
			public void faShuAttack(){
				System.out.println("甜蜜恋风");
				}
		});
		//发动法术攻击
		faShuSkillAttack();
	}
}

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

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

• 当接口作为方法的参数时,需要传递什么呢？
• 当接口作为方法的返回值类型时，需要返回什么呢？
• 其实都是它的子类对象。 ArrayList 类我们并不陌生，查看API我们发现，实际上，它是 java.util.List 接口的实现类。所以，当我们看见 List 接口作为参数或者返回值类型时，可以将 ArrayList 的对象进行传递或返回。

public class Test{
    public static void main(String[] args) {
        // 创建ArrayList集合,并添加数字
        ArrayList<Integer> arrayList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
                arrayList.add(i);
            }
        /* 获取偶数集合因为getEvenNum方法的参数是List,
        而ArrayList是List的子类,所以arrayList可以传递*/
        List list = getEvenNum(arrayList);
        System.out.println(list);
        }

    //定义一个方法（返回值类型为List类型）：保存偶数
    //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;
    }
}