final（最终的）、abstract（抽象）、interface（接口）、访问修饰符、equals方法重写

final

概念：final最终的，用来修饰方法、属性、类

修饰类：

语法：public final class Animal{}

作用：final修饰的类无法被继承

使用场景：不希望被继承，不希望代码被复制

修饰方法：

语法：public final void eat(){}

作用：final修饰的方法不能被重写

场景：不希望类有差异化

修饰变量：

语法：final 标识符

作用：

final修饰的局部变量只能被赋值一次

final修饰的成员变量必须手动初始化，不能自动初始化
final修饰引用变量，引用绑定的地址不能改变，到那时引用指向内部的数据可以改变

复习一些概念：

常量：经赋值不能改变的量

常量一般标识符全大写

常量一般用public static final 定义

重要结论：final修饰的变量只能赋值一次

访问修饰符

访问修饰符的类型：public （公开）、protect（受保护）、默认、private（私有）

看一张表就能清楚的区分

访问级别	访问修饰符	同类	同包	子类	不同包
公开	public	✔	✔	✔	✔
受保护	protect	✔	✔	✔	×
默认	没有修饰符	✔	✔	×	×
私有	private	✔	×	×	×

包命名

最好是小写

公司网址反写，www.alibaba.com com.alibaba.项目名.模块.功能名

行业后缀：.com 商业类 .gov政府类

package 使用规则

同一个包相互调用，不需要写报名，直接调用

不同的包相互调用需要些包名，才能找到对应的类

package必须出现在第一行

import 导入包

import关键字，写在package下面

import 包名，自动导包

import* 导入全部包，不推荐

eclipse alt+/ 自动导包

abstract（抽象）

概念：abstract 挂剪子就是抽象，修饰类、方法

修饰类

语法：abstract class Animal{ }

抽象类，不能被实例化，能被其他类继承

抽象类也有构造函数，但是给继承类调用的

abstract final 不同同时修饰一个方法或者一个类

使用场景：

类型太多、类与类之间有相同的属性和行为

为了降低代码的耦合度，提高代码的拓展性（多态）

修饰方法

语法：public abstract void eat（）；

特点：

抽象方法没有方法体，以；结尾

抽象方法必须被非抽象子类重写，抽象子类可以不重写

抽象方法最终一定会被非抽类继承，如果没有被非抽象类继承，抽象类无意义

抽象方法只能出现在抽象类中，抽象类中既可以有抽象方法，也可以有非抽象方法

什么时候使用抽象类：

规范子类的行为，不同子类的行为有差别

接口

概念：接口是一种标准、规范

java接口是一种引用数据类型

语法：public interface USB（）{}

场景、什么时候使用

希望封装者、调用者遵守一个共同的规则

特点：

接口是一种引用数据类型，也是特殊的抽象类class

编译之后还是生成class文件，所有也是引用数据类型

接口里面可以有属性

接口里面的方法都是abstract方法，修饰符列表public abstract，所以sun公司允许省略不写，但方法还是抽象方法

接口里面的属性都是常量，修饰符列表public static final，也可省略

接口可以类被实现implements

引用数据类型描述方法

[修饰符列表] interface 接口名 {}

[修饰符列表] abstract class 抽象名 {}

[修饰符列表] class 类名 {}

都可以使用多态

接口和类的区别

接口是特殊的抽象类

接口用interface修饰，类用class修饰

类可以继承另一个类extands；接口与接口之间可以用多个extands继承；类与接口之间有实现关系；用implements

一个类只能继承另一个父类，接口是多继承，接口的多继承是为了弥补类单继承缺陷

一个类在继承另一个类的同时，也可以实现那多个接口，但是接口不能实现那个另一个接口（接口不能implements 接口）

复习一下equals方法重写

equals重写：判断两个对象属性是否相等

题目描述：传入一个Person，姓名：李强，年龄：21，性别：男，判断与另一个Person对象属性是否相等，通过重写equals实现

package oneday;
public class equalsChongZai {
    public static void main(String[] args) {
        Person p1 = new Person("李强",21,false);
        Person p2 = new Person("李强",21,false);
        System.out.println(p1.equals(p2));
    }
}
class Person {
    private String namel;
    private int age;
    private boolean sex;
    
//  重写equals方法，判断两个Person属性是否相同
    public boolean equals(Object obj) {
        if(this == obj) { //this表示当前
            return true;
        }
        if(obj instanceof Person){  //判断obj 引用指向Person对象
            Person p = (Person)obj;  //向下转型,基本数据类型可以直接==判断，引用数据类型用equals判断
            return p.namel.equals(this.namel)&&p.age==this.age&&p.sex==this.sex;
        }
        return false;
    }
    
//  构造函数
    public Person(){}
    public Person(String namel, int age, boolean sex) {
        super();
        this.namel = namel;
        this.age = age;
        this.sex = sex;
    }
//  get/set 方法
    public String getNamel() {
        return namel;
    }
    public void setNamel(String namel) {
        this.namel = namel;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public boolean isSex() {
        return sex;
    }
    public void setSex(boolean sex) {
        this.sex = sex;
    }
}

运行结果为true

后感：感觉对重写、继承、多态还是不太理解

        if(obj instanceof Person){  //判断obj 引用指向Person对象
            Person p = (Person)obj;  //向下转型
            return p.namel.equals(this.namel)&&p.age==this.age&&p.sex==this.sex;
            //基本数据类型可以直接==判断，引用数据类型用equals判断
        }

这段代码纠结挺久的，好在最终是实现了需求

我正在参与掘金技术社区创作者签约计划招募活动，点击链接报名投稿。

final（最终的） 、abstract（抽象）、interface（接口）、访问修饰符、equals方法重写