final，权限，内部类，引用类型

第一章 final关键字

1.1 概述

学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写，那么我们能不能随意的继承API中提供的类，改写其内容尼？显然这是不合适的。为了避免这种随意该写的情况， java 提供了 final 关键字，用于修饰不可改变内容
final：不可改变。可以用于修饰类，方法和变量。

• 类：被修饰的类，不能被继承。
• 方法：被修饰的方法，不能被重写。
• 变量：被修饰的变量，不能被重新赋值。
  我们上代码：先写一个父类（Fu），再写一个子类（Zi），子类继承父类，父类先不加final

父类

package com.mystep.step.demo1;

/**
 * @author step
 * @date 2021年07月27日 21:29
 */
public  class Fu {
    public void method(){
        System.out.println("父类的方法！");
    }
}

子类

package com.mystep.step.demo1;

/**
 * @author step
 * @date 2021年07月27日 21:30
 */
public class Zi extends Fu{
    @Override
    public void method(){
        System.out.println("我是子类方法！");
    }
}

子类此时是正确的，当我们给父类加上 final 修饰的话我们看看，子类继承会报错

所以 final 修饰的类不能被继承

注意点 final 和 abstract 关键字不能一起使用
我们看

原因是：abstract 修饰的类或者方法都需要被重写，而final是最终的意思，不能发生改变，两个修饰符冲突了

当 final 修饰方法的时候，方法不可以被重写

我们看到子类继承父类，但是父类的方法是final修饰的，子类重写报错
如果 final 修饰方法，那么该方法就是最终方法不能被重写，如果一个类被final修饰了，那他没有任何子类，说白了就是最终类可能被继承再有子类

那如果 final 修饰局部变量我们怎么办，

package com.mystep.step.demo1;

/**
 * @author step
 * @date 2021年07月27日 21:27
 * final的含义：最终的，被他修饰的所有内容都不能再次发生变化
 * 常见的四种用法：
 *      1.可以修饰一个类
 *      2.可以修饰一个方法
 *      3.可以修饰一个局部变量
 *      4.可以修饰一个成员变量
 */
public class Demo1Final {
    public static void main(String[] args) {
        int num=10;
        System.out.println(num);
        num=20;
        System.out.println(num);
    }
}

上面的sum就是局部变量
我们看输出

我们用 final 修饰一下再看

这里直接报错，所以被

final 修饰的局部变量不可被修改，一次赋值终身使用

对于基本类型来说，不可改变就是不能改变他的数据值，

对于引用数据类型来说
我们举例子
首先我们注意一点：在Java一般使用HashCode来代表对象的地址，但是两个相同的对象就不行了，两个相同的对象的hashcode是相同的。
我们引入一个学生类

package com.mystep.step.demo1;

import lombok.AllArgsConstructor;

/**
 * @author step
 * @date 2021年06月22日 23:40
 */

public class Student {
    private Long id;
    private String name;//名字
    private int sex;//性别
    public Student(){
       
    }
    public Student(Long id,String name,int sex){
        this.id=id;
        this.name=name;
        this.sex=sex;
    }
    public Student(String name,int sex){
        this.sex=sex;
        this.name=name;
    }
    public Long getId() {
        return id;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sex=" + sex +
                '}';
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getSex() {
        return sex;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }
}

我们上测试类，我们使用System.out.println(System.identityHashCode(s));来打印他的hashcode,注意观察

package com.mystep.step.demo1;

import javax.sound.midi.Soundbank;

/**
 * @author step
 * @date 2021年07月27日 21:27
 * final的含义：最终的，被他修饰的所有内容都不能再次发生变化
 * 常见的四种用法：
 *      1.可以修饰一个类
 *      2.可以修饰一个方法
 *      3.可以修饰一个局部变量
 *      4.可以修饰一个成员变量
 */
public class Demo1Final {
    public static void main(String[] args) {
        Student s =new Student("桂纶镁",0);
        System.out.println(System.identityHashCode(s));
        System.out.println(s.getName());
        System.out.println(s.getSex());
        s=new Student("周杰伦",1);
        System.out.println(System.identityHashCode(s));
        System.out.println(s.getName());
        System.out.println(s.getSex());
    }
}

运行，我们看打印结果

一个是9开头一个是1开头的很明显就不一样
接下来我们使用 final 修饰一下看看
同样是启动类

package com.mystep.step.demo1;

import javax.sound.midi.Soundbank;

/**
 * @author step
 * @date 2021年07月27日 21:27
 * final的含义：最终的，被他修饰的所有内容都不能再次发生变化
 * 常见的四种用法：
 *      1.可以修饰一个类
 *      2.可以修饰一个方法
 *      3.可以修饰一个局部变量
 *      4.可以修饰一个成员变量
 */
public class Demo1Final {
    public static void main(String[] args) {
        Student s =new Student("桂纶镁",0);
        System.out.println(System.identityHashCode(s));
        System.out.println(s.getName());
        System.out.println(s.getSex());
        s=new Student("周杰伦",1);
        System.out.println(System.identityHashCode(s));
        System.out.println(s.getName());
        System.out.println(s.getSex());
        System.out.println("=======华丽分割线=======");
         final  Student s1=new Student("周星驰",1);
        System.out.println(System.identityHashCode(s1));
        System.out.println(s1.getName());
        System.out.println(s1.getSex());
        s1.setName("周星星");
        System.out.println(System.identityHashCode(s1));
        System.out.println(s1.getName());
        System.out.println(s1.getSex());
    }
}

当我们继续给s1 new一个的时候,报错，

不可以对final修饰的引用类型，来修改他的内存地址

我们看正常打印结果

我们看到桂纶镁和周杰伦的cold是不同的，周星星和周星驰的是一样的f
对于引用数据类型来说，不能改变数据类型的内存地址
我们定义一个Person类，我们看到name属性报错，说明什么
对于成员变量来说，如果使用final修饰，必须立马初始化而且，这个成员变量不能生成set方法

给赋值初始化方式有两种：
  一种是显示初始化（age=0）
  另一种赋值方法：构造方法初始化赋值（this.name=name）

查询API我们发现，像 public final class String， public final class Math， public final class Scanner 等，很多我们学过的类，都是被final 修饰的，目的就是供我们使用，而不是让我们随意改变其内容
我们再来看看常量（书写要求：被final修饰的所有常量字母都要大写）

我们需要记住，约定大于规范，就是这样

第二章 权限修饰符

2.1 概述

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

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

2.2 不同权限的访问能力

说白了就是

可见，public 具有最大权限，private 则是最小权限
编写代码时，如果没有特殊的考虑，建议这样使用权限：

• 成员变量使用 private ，隐藏细节。
• 构造方法使用 public ，方便创建对象。
• 成员变量使用 public ，方便调用方法。
  小贴士：不加权限修饰符，其访问能力与 default 修饰符相同

第三章 内部类

3.1 什么是内部类

将一个类A 定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类
如果一个事物的内部包含另外一个事物，那么这个类就包含着另外一个类。
例如：
身体和心脏，汽车和发动机之类

4种分类：

•   静态内部类
•   成员内部类
•   局部内部类（包含匿名类）
•   匿名内部类

成员内部类

成员内部类的定义格式：

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

	**使用成员内部类有两种方式**

1.间接方式：在外部类的方法中，使用内部类，然后再别的方法调用外部类的方法1.
2.直接方式

•   类名称  对象名 = new 类名称（）；
  

• 【外部类名称.内部类名称 对象名 = new 外部类名称（）. new 内部类名称() 】

注意：内部类用外部类，随便用，外用内，需要创建内部类对象。

例如：我们建个几个类
类一Body：

package com.mystep.step.demo2;

/**
 * @author step
 * @date 2021年07月30日 1:04
 */
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("外部类的成员方法！");
//        beat();
        new Heart().beat();
    }
    //生成get set方法

    public String getName() {
        return name;
    }

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

类二启动类：

package com.mystep.step.demo2;

/**
 * @author step
 * @date 2021年07月30日 1:12
 */
public class Demo2InnerClass {
    public static void main(String[] args) {
        Body body=new Body();
        body.setName("step");
        body.methodBody();
        //只能访问自己的方法
        //间接的调用了内部类的方法
    }
}

输出结果

我们看到外部类使用内部类的心脏方法，爆红出错了

我们看下面这张图。这个方法

为什么是 null 因为我们这次new完之后没有给他触发他的成员变量，我们没有赋值
但我们在外部类和内部类中同时定义相同的属性的时候
如下：

我们发现他用的是内部类的东西，但我们如果想用外部类的时候
我们需要

• 对象.this.属性
  

局部内部类

局部内部类：如果一个类定义在一个类的方法中，那么他就称之为局部内部类（我们学习Spring 动态代理的时候我们会见到）
只有当前所属的方法可以使用，除了方法就不能使用
局部内部类：如果希望访问所在方法的局部变量，那么这个局部变量必须是局部变量

局部内部类的修饰符什么都不能写，成员内部类的修饰符可以写的

打印结果

内部类如果用外部类，直接使用，外部类用内部类，创建对象

3.2 匿名内部类【重点】

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

• 1.定义子类
• 2.重写接口中的方法
• 3.创建子类对象
• 4.调用重写后的方法
  我们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是做这样的快捷方式
  前提
  匿名内部类必须继承一个父类或者实现一个父接口
  我们创建一个接口

package com.mystep.step.demo5;

/**
 * @author step
 * @date 2021年07月30日 22:06
 */
public interface MyInterface {
    void method();
    void method2();
}

我们知道接口是需要通过实现类来实现的
在来一个类

package com.mystep.step.demo5;

/**
 * @author step
 * @date 2021年07月30日 22:05
 */
public class DoMain {
    public static void main(String[] args) {
        MyInterface obj=new MyInterface() {
        //匿名内部类，不是匿名对象
            @Override
            public void method() {
                System.out.println("匿名内部类");
            }

            @Override
            public void method2() {
                System.out.println("mi匿名");
            }
        };
        obj.method();
        obj.method2();
    }
}

• new MyInterface() {}代表创建一个对象MyInterface的对象
• 大括号{}。具体内部类的实现过程
• 匿名内部类在创建对象的时候只能使用一次，因为它在方法里头，方法被使用完以后就销毁，
• 如果希望多次创建对象，而且类的类名一样的话，那么我们需要单独定义一个实现类、
• 匿名对象在调用方法的时候之能调用一次，下次调用相当于新创建一个对象
  
  这里可以调用obj的方法，这个匿名内部类有名称（obj），他是 MyInterface 类型的

第四章 引用类型用法总结

实际的开发中，引用类型的使用非常重要，也是非常普遍的，我们可以在理解基本类型的使用方式基础上，进一步 去掌握引用类型的使用方式，基本类型可以作为成员变量，作为方法的参数，作为方法的返回值，那么当然引用类型也是可以的。
我们看例子
这个例子有点没意义

package com.mystep.step.demo6;

/**
 * @author step
 * @date 2021年07月31日 0:32
 */
public class Role {
    private int id;//角色
    private int blood;//生命值
    private String name;//角色名称
    //添加武器属性
    private Weapon wp;
    //添加盔甲属性
    private Armour ar;
    //提供get/set 方法
    public Weapon getWp(){
        return wp;
    }
    public void setWeapon(Weapon wp){
        this.wp=wp;
    }
    //生成get set方法
    }

使用 int 类型表示 角色id和生命值，使用 string 类型表示姓名，此时，string 本身就是引用类型，由于使用的方式类似常量，所以往往忽略了它是引用类型的存在，如果我们继续使用丰富这个类的定义，给 Role 增加武器，穿戴装备等属性，我们将如何编写尼？
定义武器类，将增加攻击能力：

package com.mystep.step.demo6;

/**
 * @author step
 * @date 2021年07月31日 0:37
 */
public class Weapon {
  private  String name;//武器名称
   private int hurt;//伤害值
}
//生成get，set方法

定义穿戴盔甲类，将增加防御能力，也就是提升生命值：

package com.mystep.step.demo6;

/**
 * @author step
 * @date 2021年07月31日 0:39
 */
public class Armour {
   private String name;//装备名称
   private int protect;//防御力
}
//生成get，set方法

我们更改一下角色类

package com.mystep.step.demo6;

/**
 * @author step
 * @date 2021年07月31日 0:32
 */
public class Role {
    private int id;//角色
    private int blood;//生命值
    private String name;//角色名称
    //添加武器属性
    private Weapon wp;
    //添加盔甲属性
    private Armour ar;
    //提供get/set 方法
    public Weapon getWp(){
        return wp;
    }
    public void setWeapon(Weapon wp){
        this.wp=wp;
    }
    //生成get set方法
    }
    

我们看下面，这个就是引用类型的具体实现

如果一个类的内部成员变量是个引用类型，那么该引用类型的方法我们都可以使用
举例：我们玩电脑游戏，我们使用的是电脑的方法

4.2 interface作为成员变量

接口是对方法的封装，接口作为成员变量时，对它进行赋值操作，实际上，是赋给他该接口的一个子类对象

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

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