java004
子类访问权限
访问权限修饰符，关键字，用来修饰类、属性、方法，不同的访问权限修饰符表示不同的作用域
修饰符 同一个类 同一个包 不同包 子类
public 可以访问 可以访问 可以访问 可以访问
protected 可以访问 可以访问 不可以访问 可以访问
默认修饰符 可以访问 可以访问 不可以访问 不可以访问
private 可以访问 不可以访问 不可以访问 不可以访问
多态
一个元素具有多种不同的形态，在不同的应用场景中可以以不同的形态呈现，来满足当下的业务需求
如何具体实现，使用继承来实现
方法重写：子类在继承父类方法的基础上对该方法进行重写定义
public class Member {
public void buyBook(){
}
}
1
2
3
4
5
public class Cashier {
private Member member;
public Member getMember() {
return member;
}
public void setMember(Member member) {
this.member = member;
}
public void settlement(){
this.member.buyBook();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class OrdinaryMember extends Member {
public void buyBook(){
System.out.println(“普通会员买书打9折”);
}
}
1
2
3
4
5
public class SuperMember extends Member {
public void buyBook(){
System.out.println(“超级会员买书打6折”);
}
}
1
2
3
4
5
public class VIPMember extends Member {
public void buyBook(){
System.out.println(“VIP会员买书打5折”);
}
}
1
2
3
4
5
public class VVIPMember extends Member {
public void buyBook(){
System.out.println(“VVIP会员买书免费”);
}
}
1
2
3
4
5
public class Test {
public static void main(String[] args) {
OrdinaryMember ordinaryMember = new OrdinaryMember();
SuperMember superMember = new SuperMember();
VIPMember vipMember = new VIPMember();
VVIPMember vvipMember = new VVIPMember();
Cashier cashier = new Cashier();
cashier.setMember(vvipMember);
cashier.settlement();
}
}
1
2
3
4
5
6
7
8
9
10
11
抽象
封装、继承、多态、抽象
抽象类和抽象方法
抽象方法：没有方法体的方法
一个类中一旦包含任意一个抽象方法，则该类就需要定义为抽象类
public abstract class Member {
public abstract void buyBook();
}
1
2
3
抽象类不能被实例化，抽象类不能通过 new 的方式来创建对象
一旦一个类继承了一个抽象类
1、重写父类中的抽象方法，把抽象的东西具体化
2、如果不去重写父类中的抽象方法，则该类也必须定义为抽象类
public abstract class Member {
public abstract void buyBook();
}
1
2
3
public class MyMember extends Member {
@Override
public void buyBook() {
}
}
1
2
3
4
5
6
7
Object 类
Object 是 Java 提供的一个类，位于 java.lang 包中，该类是所有类的直接父类或间接父类。
Object 是所有类的祖先，一个类在定义时如果不通过 extends 指定其直接父类，系统就会自动为该类继承 Object 类。
Object 类中有三个方法一般需要进行重写
方法 描述
public String toString() 以字符串的形式返回该类中的实例化对象信息
public boolean equals(Object obj) 判断两个对象是否相等
public native int hashCode() 返回对象的散列码
toString
public String toString() {
return getClass().getName() + “@” + Integer.toHexString(hashCode());
}
1
2
3
public class Account {
private int id;
private String name;
private int age;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
equals
public boolean equals(Object obj) {
return (this == obj);
}
1
2
3
import java.util.Objects;
public class Account {
private int id;
private String name;
private int age;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || this.getClass() != o.getClass()) return false;
Account account = (Account) o;
return this.id == account.id &&
this.age == account.age &&
this.name.equals(account.name);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
hashCode
public native int hashCode();
1
用 native 修饰的方法叫做本地方法，由 Java 定义方法，由其他语言 （C++） 进行方法的实现
Java 语言的特性是面向应用层的语言，不能操作底层操作系统层面的数据，所以很多方法就受限，无法完成一些偏向底层的操作，如何解决？
通过本地方法的形式来解决，由 Java 定义，由 C++ 实现（C++ 可以操作操作系统底层数据的）
获取对象在内存中的散列码：内存地址 + 对象信息（属性信息）混合成一个 int 类型的数据，可以映射到内存地址
hashCode 用来判断两个对象是否相等的，不就会和equals 方法冲突了吗？
一般情况下，这个两个方法 hashCode 和 equals 是结合起来使用的，共同判断两个对象是否相等？
因为 hashCode 和 equals 方法的效率不一样，hashCode > equals
hashCode 虽然效率高，但是它存在一些问题
如果两个对象的 hashCode 不相等，则这两个对象一定不相等
如果两个对象的 hashCode 相等，不代表这两个对象一定相等
1、先用 hashCode 进行判断，如果不相等，则直接返回结果两个对象不相等，如果相等，则 hashCode 此时无法断定两个对象是否相等
2、再使用 equals 方法进行进一步的判断
import java.util.Objects;
public class Account {
private int id;
private String name;
private int age;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || this.getClass() != o.getClass()) return false;
Account account = (Account) o;
return this.id == account.id &&
this.age == account.age &&
this.name.equals(account.name);
}
@Override
public int hashCode() {
return id*age;
}
}