java继承、多态和反射


阅读数: 次   

继承

如果两个对象存在“is-a”关系，即某某是某某，可以使用继承。
使用关键字extends表示继承（c++中是 : ）,关键字extends表示正在构造的新类派生于一个已存在的类。这个已存在的类称之为基类，超类，父类；新类 称为子类、派生类

1. 覆盖方法

超类中的一些方法对子类不一定适用，需要提供一个新的方法覆盖超类中的方法。

  • 现假设有一个Employee(雇员类)和Manager(经理类),其中Employee中有一个薪资getSalary()方法及加薪raiseSalary()方法,Manager有一个奖金setBonus()方法.
  • Manager继承Employee

Employee类

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
public class Employee {
    private String name;//姓名
    private double salary;//工资
    private LocalDate hireDay;//雇佣时间

    public Employee(String name, double salary, int year, int month,int day) {
        this.name = name;
        this.salary = salary;
        hireDay = LocalDate.of(year,month,day);
    }

    public String getName() {
        return name;
    }

    public double getSalary() {
        return salary;
    }

    public LocalDate getHireDay() {
        return hireDay;
    }
    public void raiseSalary(double byPercent){//涨工资
        double raise = salary * byPercent / 100;
        salary += raise;
    }
}

Manager类

1
2
3
4
5
6
7
8
9
10
11
12
public class Manager extends  Employee{
    private double bonus;//奖金

    public Manager(String name, double salary, int year, int month, int day) {
        super(name, salary, year, month, day);
        bonus = 0;
    }

    public void setBonus (double b){
        bonus = b;
    }
}

Manager类中的getSalary()方法应该返回薪资和奖金的总和.所以需要在Manager中提供一个新的方法来覆盖超类Employee中的方法

1
2
3
4
5
6
7
8
public class Manager extends  Employee{
    .
    .
    public double getSalary() {
       .
       .
    }
}
  1. 刚开始一般都会这么想
1
2
3
public double getSalary() {
       return salary + bonus; //报错
   }

salary是Employee类的私有成员，只有他自己能够访问

  1. 那么可不可以调用Employee的访问器来访问salary呢?
1
2
3
4
public double getSalary() {
        double baseSalary = getSalary(); //报错
        return baseSalary +bonus;
    }

这是个死循环，覆盖的方法名和被覆盖的方法的名字是保持一致的！，它会首先在本类中寻找，因此这个方法会无限调用自己，应该使用关键字super来访问Employee中的getSalary方法

1
2
3
4
public double getSalary() {
        double baseSalary = super.getSalary();
        return baseSalary +bonus;
    }

super和this相对应，一个表示父类，一个表示本身

警告：在覆盖方法时，子类方法不能低于超类方法的可见性！

1.1. 关于变量的访问顺序

如果在子类方法中访问一个变量

  1. 现在子类局部变量找
  2. 子类成员范围找
  3. 父类成员范围找（非私有）
  4. 没找到就报错

方法中的局部变量会覆盖成员变量，虽然也可以使用super和this来访问成员变量，但是在子类方法中定义的局部变量要尽量不与成员变量同名！

2. 子类构造器

子类构造器一定要调用超类的构造器，如果子类构造器没有显式地调用超类的构造器，将自动调用超类的无参构造器
但是如果超类没有提供无参构造器，子类又有没有显式地调用超类其他构造器，java编译器会报错！

3. 多态

在java中，对象变量是多态的。
例如

1
2
3
Employee e;
e = new Employee();
e = new Manager();//Manager继承自Employee，这也是正确的

即一个对象变量即可以引用其本身类型的变量，也可以引用任何一个子类的对象.

但是： 编译器只将e看做是Employee的对象，e只能访问Employee类的方法，不能访问子类特有的方法。

1
2
3
4
5
6
7
//Manager类有个自己的方法setBonus
Manager boss = new Manager(...);
Employee[] staff = new Employee[3];
staff[0] = boss;//父类对象变量引用子类对象
boss.setBonues(5000);//正确
staff[0].setBonues(5000);//错误
//因为staff[0]声明的类型为Employee，而setBonus不是Employee类的方法

注意： 子类不能引用父类

1
Manager m = staff[1];//error;

3.1. 多态的前提和体现

  • 有继承/实现关系
  • 有方法重写
  • 有父类引用指向子类对象

3.2. 多态的好处与弊端

  • 提高了程序的拓展性：定义方法的时候，使用父类型作为参数，将来使用的时候可以使用子类作为参数
  • 不能使用子类特有的功能

4. 理解方法调用

  1. 编译器查看对象的声明类型和方法名

  2. 确定方法调用中提供的参数类型

  3. 静态绑定：如果是static、private、final方法或者构造器，编译器将准确地知道应该调用哪个方法

  4. 动态绑定：程序运行并且采用动态绑定（多态）调用方法时，虚拟机必须调用与x所引用对象的实际类型所对应的方法。假设x的实际类型为d，它是c的子类，如果d定义了这个方法就会调用这个方法；否则将在d类的超类中寻找。

    4.1. 阻止继承：final类和方法法

    将某个特定的方法声明为final，子类就不可以重写（覆盖）这个方法。
    将某个类声明为final，其中所有的方法都会被声明为final，但不包括字段

5. 强制类型转换

当一个父类对象变量引用子类对象时，如果要访问子类独有的方法，则需要进行强制类型转换

1
2
3
Employee[] staff = new Employee[3];
staff[0] = new Manager();
Manager boss = (Manager)staff[0];//正确,staff[0]为Manager的一个实例

前提是父类对象变量的实际类型要与转换类型一致，如果不一致将会发生错误

1
Manager boss = (Manager)staff[1];//error,staff[1]的实际类型时Employee

因此在进行强制转换前，最好检查一下是否能成功地转换

1
2
3
4
if(staff[1] instanceof Manager)
{
   boss = (Manager)staff[1];
}//检查是否为Manager的一个实例,是返回true，在这里返回false

综上所述：

  • 只能在继承层次内进行强制类型转换
  • 在将超类强制转换为子类之前，应该使用instanceof进行检查

6. 抽象类

可以用关键字abstract来声明一个类，说明这个类为抽象类。

1
2
3
public abstract class animal {
       ......
}

说明这个类不能被实例化，也就是不能创建抽象类的对象

1
animal an = new animal();//error

不过可以定义一个抽象类的对象变量，只能引用非抽象子类的对象

1
2
3
4
public class cat extends animal {//非抽象子类
      ......
}
animal an = new cat();//引用子类对象

可以将方法声明为抽象方法，那么就不需要实现这个方法了

1
2
3
public abstract class animal {
    abstract public void eat();//不需要在此类中实现
}

抽象方法的功能由其子类实现，抽象类的子类要么重写抽象类中的抽象类，要么也定义为抽象类！

注意事项:

  • 抽象方法必须在抽象类中，有抽象方法的类一定为抽象类，但抽象类可以没有抽象方法。
  • 抽象类可以有构造器，主要用于子类访问父类数据的初始化。
  • 抽象方法类似于c++中的纯虚函数。
  • 将通用字段和方法放在超类中

7. 访问修饰符小结

修饰符 权限
private 仅对本类可见
public 对外部完全可见
protected 对本包和所有子类可见
默认，不需要修饰符 对本包可见

8. Object：所有类的超类

java中每个类都扩展了Object，如果没有明确指出超类，Object就被认为是这个类的超类。

可以使用Object类型的变量引用任何类型的对象

1
Object obj = new Employee();

但如果相对其中的内容进行具体的操作，需要进行强制转换

1
Employee e = (Employee)obj;

8.1. equals方法

Object类中的equals方法用于检测一个对象是否等于另一个对象，但只是确定两个对象引用是否相等。

我们来看一下equals方法的源码

1
2
3
public boolean equals(Object obj) {
    return this == obj;
}

他依然是比较两个对象的地址值，只有当两个变量引用同一个对象时才会相等，这和“==”是等效的！

1
2
3
4
5
6
animal a = new cat();
animal b = new cat();
System.out.println(a.equals(b));//false

a = b;//引用同一个对象
System.out.printlln(a.equals(b));//true

如果要比较两个对象的内容是否相等，需要对equals方法进行重写。
在子类定义equals方法时，首先调用父类的equals进行比较（因为通用字段在父类中）。如果超类字段都相等，再比较子类字段。

为了防备两边都为null的情况，有一种Objects.equals(a,b)方法。如果两边都为null，返回true；只有一个为null，返回false；都不为null，则调用a.equals(b).

java中对于equals方法的规则如下：

  • 自反性：对于任何非空引用x，x.equals(x)应该返回true。
  • 对称性：对于任何x和y，当且仅当y.equals(x)返回true时,x.equals(y)返回true.
  • 传递性：对于任何引用x,y,z,如果x.equals(y)为true，y.equals(z)为true，那么x.equals(z)为true。
  • 一致性：如果x和y的引用没有发生变化，反复调用x.equals(y)应该返回同样的值。
  • 对于任何非空引用x,x.equals(null)应该返回false。

idea中可以用快捷键重写，重写equals时也会自动重写hashcode。

8.2. hashCode方法

x.hashCode()返回散列码，Object默认会从对象的存储地址得出散列码。

equals与hashCode的定义必须相容:如果x.equals(y)返回true，那么x.hashCode()与y.hashCode()返回相同的值.

8.3. toString方法

源码为

1
2
3
public String toString() {
    return this.getClass().getName() + "@" + Integer.toHexString(this.hashCode());
}//打印对象的类名和散列码

idea中也可以用快捷键重写

如果x是一个任意对象，并调用System.out.println(x),println方法会简单地调用x.toString方法，并打印输出得到的字符串。

数组继承了Object类的toString方法，并没有覆盖

1
2
int[]arr = new int[]{1,2,3};
System.out.println(arr);//结果为[I@4411d970

因此要打印数组，要调用静态方法Arrays.toString

1
2
System.out.println(Arrays.toString(arr));
//结果为[1, 2, 3]

9. 泛型数组列表ArrayList

ArrayList相当于c语言中的顺序表（Linklist相当于链表），它是一个泛型类。

声明和构造一个数组列表

1
ArrayList<String> objects = new ArrayList<>();//右边的<>内容可以省略

尖括号内的类型参数不允许是基本类型！ 要使用包装器。

使用add方法将元素添加到数组列表当中

1
2
3
objects.add("hello");
objects.add("world");
System.out.println(objects);//[hello, world]

如果调用add而内部数组已满，数组列表就会自动地创建一个更大的数组，并将所有的对象从较小的数组中拷贝到较大的数组中。

如果已经知道或能够估计出数组可能存储的元素数量，就可以在填充数组之前调用ensureCapacity方法

1
objects.ensureCapacity(100);//分配一个包含100个对象的内部数组

这样一来，前100次add调用不会带来开销很大的重新分配空间，或者还可以这样

1
ArrayList<String> objects = new ArrayList<>(100);//直接传给构造器

数组列表的容量和数组的大小是有区别的，容量只是可能保存的元素的个数；而数组的大小就说明有这么多个空位置可以使用。

9.1. 访问数组列表的元素

不能像数组一样用[ ]来访问元素，而是用get来访问数组列表的元素。

1
2
3
4
5
6
7
ArrayList<String> objects = new ArrayList<>(3);
objects.add("hello ");
objects.add("world ");
objects.add("java!");
System.out.println(objects.get(0)+objects.get(1)+objects.get(2));
//打印结果
//hello world java!

如果要修改某个元素的值，则要使用set方法

1
2
3
objects.set(2,"yeah!");
System.out.println(objects.get(0)+objects.get(1)+objects.get(2));
//hello world yeah!

数组列表的容量和实际大小是不同的

1
2
3
4
5
6
ArrayList<String> objects = new ArrayList<>(5);
objects.add("hello ");
objects.add("world ");
objects.add("java!");
System.out.println(objects.size());//容量为5，大小为3
objects.set(3,"a");//error,只有当实际大小大于3时才能设置

还可以删除数组列表中的某个元素

1
2
3
String str = objects.remove(2);//返回被删除的元素
System.out.println(objects.size());//2
System.out.println(objects);//[hello , world ]

for each循环也同样适用于数组列表

1
2
3
4
5
6
        for(String s:objects){
            System.out.println(s);
        }
//hello 
//world 
//java!

9.2. 对象包装器和自动装箱

所有基本类型都有一个与之对应的类，这些类称之为包装器。
|基本类型| 包装器 |
|–|–|
|int |Integer |
|long|Long|
|float|Float|
|short|Short|
|byte|Byte|
|char|Character|
|boolean|Boolean|

同时包装器类还是final，不能派生他们的子类。

对于那些泛型类包容的是对象类型，即泛型类的类型参数要是对象。而基本类型不是对象，可以用包装器代替基本类型。

1
2
ArrayList<int> list = new ArrayList<>();//error
ArrayList<Integer> list = new ArrayList<>();//ok

有一个很方便的特性能将基本数据类型传进数组列表

1
2
3
4
list.add(3);//ok，等价于以下形式
list.add(Integer.valueOf(3));//会将3自动包装

int n = list.get(i);//ok，将一个Integer对象赋给int值时会自动拆箱

自动装箱与拆箱也适用于算术表达式

1
2
Integer n = 3;//ok,装箱
n++;//自动拆箱，进行自加运算，再自动装箱

包装器和基本类型有一点很大的不同，基本类型可以用”==”进行比较，而包装器是引用类型，要用equals方法进行比较。

最后强调一下，装箱和拆箱是编译器要做的工作，而不是虚拟机。

如果想要构造一个Integer对象,则需要使用工厂方法

1
Integer integer = Integer.valueOf(String s);//s为数字字符串

10. 参数数量可变的方法

可以提供参数数量可变的方法，用…即可

1
2
3
4
public static void meth(int...num){
   for(int n:num){
     System.out.print(n);
}

括号中的参数都为int类型，参数的个数是可变的，调用以上方法

1
2
meth(1,2,3,4,5,6);
//结果为123456

可见，参数int…num实际为数组，可以看成int[ ]num，它将所有的参数保存在数组之中，具体事例可以参考printf方法的实现。

11. 枚举类

对于定义一个枚举类型

1
public enum size{small,mid,large}

这个声明定义的类型是一个类，它刚好有四个事例，不可能构造新的对象。
比较两个枚举类型的值可以直接使用==

我们也可以为其添加构造器，方法和字段

1
2
3
4
5
6
7
8
public enum size{
    small("s"),mid("m"),large("l");
    private String abbrevuation;
    private size(String s){
        this.abbrevuation = s;
    }
    public String getAbbrevuation(){return abbrevuation;}
}

枚举类的构造器总是私有的。

所有枚举类型都是Enum类的子类，其中继承过来的toString方法将返回枚举常量名。

1
2
3
size s = size.small;
System.out.println(s.toString());
//输出small

每个枚举类型都有一个静态的values方法，它将返回一个包含全部枚举值的数组。

1
2
3
4
5
size[] si = size.values();
for(size size:si){
    System.out.println(size);
}
//输出small mid large

compareTo可以用来比较两个枚举常量的大小，实现略

12. 反射

java反射机制，是指在运行时去获取一个类的变量和方法信息，然后通过获取到的信息来创建对象，调用方法的一种机制。

12.1. 获取Class类的对象

要想通过反射去使用一个类，首先我们要获取该类的字节码文件对象，也就Class类型的对象。

这里有个测试类

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
package reflection;
public class test {//测试类
    private int age;//年龄
    private String name;//姓名
    private String address;//地址

    public test() {
        age = 0;
        name = "none";
        address = "earth";
    }//无参构造函数
    public test(int a,String n,String add){
        age = a;
        name = n;
        address = add;
    }
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "test{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

有三种方法来获取该测试类的Class对象

1
2
3
4
5
6
Class<test> testClass = test.class;

Class<?> testClass = Class.forName("reflection.test");//类的位置

test a = new test();
Class<? extends test> aClass = a.getClass();

Class类是一个泛型类，它表示每个类运行时的类型信息，每个类都有个Class类的对象。

虚拟机为每个类型管理一个唯一的Class对象，因此可以用==来实现两个类对象的比较

1
2
test t = new test();
System.out.println(test.class==t.getClass());//true

12.2. 反射获取构造方法并使用

如果有一个Class类型的对象，可以用它构造类的实例。调用getConstructor方法将得到一个Constructor类型的对象，然后使用newInstance方法来构造一个实例。

1
2
3
4
5
//获取class对象
Class<?> c = Class.forName("reflection.test");
//等同于test o = new test(3,"jack","北京");通过反射来构造对象
Constructor con = c.getConstructor(int.class,String.class,String.class);
Object o = con.newInstance(3, "jack", "北京");//传进参数

其中getConstructor方法中的参数为Class类型的对象，指定要调用的构造器，并且只能是非私有的构造器，如果需要获取所有类型的构造器，需要用getDeclaredConstructor方法

newInstance方法返回一个Object类的引用

12.3. 反射获取成员变量并使用

可以通过getField方法来获取成员变量，由于许多成员变量都是私有的，因此要使用getDeclaredField方法来获取私有变量，返回一个Filed对象

1
Field age = c.getDeclaredField("age");//访问变量名为age的私有变量

获取了变量之后，便可以对其进行操作，但是默认是不能对私有成员进行操作的！ 因此需要调用setAccessible方法来取消检查

1
age.setAccessible(true);

现在可以用set方法来修改成员变量,第一个参数为所要修改的对象

1
age.set(o,5);//修改对象o中的age为5

get方法来返回这个Field对象所描述的对象的值

1
System.out.println(age.get(o));//5

下面来看一个例子，要求通过反射来修改类中的字段

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
public class demo {
    public static void main(String[]args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
        //利用反射来修改类中的字段
        //获取class对象
        Class<?> c = Class.forName("reflection.test");
        //等同于test o = new test(3,"jack","北京");通过反射来构造对象
        Constructor con = c.getConstructor(int.class,String.class,String.class);
        Object o = con.newInstance(3, "jack", "北京");

        System.out.println(o);//test{age=3, name='jack', address='北京'}

        //o.age = 5
        //Field age = c.getField("age");只能访问公有字段
        Field age = c.getDeclaredField("age");
        age.setAccessible(true);//对私有的成员变量/方法都要暴力使用
        age.set(o,5);//set方法来修改成员变量,第一个参数为所要修改的成员变量所在的对象

        //o.name = "peter"
        Field name = c.getDeclaredField("name");
        name.setAccessible(true);
        name.set(o,"peter");

        //o.address = "长沙"
        Field address = c.getDeclaredField("address");
        address.setAccessible(true);
        address.set(o,"长沙");
        System.out.println(o);//test{age=5, name='peter', address='长沙'}
    }
}

//打印结果为
//test{age=3, name='jack', address='北京'}
//test{age=5, name='peter', address='长沙'}

12.4. 反射获取成员方法并使用

与获取成员变量一样，方法可以通过getMethod来获取，返回一个Method对象（这些也都是非私有的）

1
2
3
4
Method getAge = c.getMethod("getAge");//第一个参数为方法名
//调用getAge()
Method setage = cl.getMethod("setAge", int.class);//第二个参数为要调用的方法参数的class对象
//调用setAge(int)

通过invoke方法来使用调用的方法,如果返回类型是基本类型，invoke方法会返回其包装器类型，invoke方法的第一个参数为所调用方法的对象，第二个为传进方法的值

1
2
Method getAge = c.getMethod("getAge");
int a = (int) getAge.invoke(o);//int a = getAge();调用o中的getAge方法

下面来看例子，通过反射来调用方法并使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class demo2 {
    public static void main(String[]args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {
        //获得Class对象
        Class<?> cl = Class.forName("reflection.test");
        //使用反射调用方法

        //test t = new test();
        Constructor<?> constructor = cl.getConstructor();//默认构造函数
        Object o = constructor.newInstance();

        //t.getAge();
        Method getAge = cl.getMethod("getAge");//先得到方法
        int a = (int) getAge.invoke(o);//如果返回类型是基本类型，invoke方法会返回其包装器类型
        System.out.println(a);//默认值为0

        //t.setAge(12);
        Method setage = cl.getMethod("setAge", int.class);
        setage.invoke(o,12);//第一个参数是所要调用方法的对象，可以看做调用o的setage方法
        a = (int) getAge.invoke(o);//通过invoke来使用方法
        System.out.println(a);//值为12

        //对于静态方法，invoke中的第一个参数可以忽略
    }
}

12.5. 通过反射越过泛型检查

对于泛型类ArrayList，一旦尖括号中的类型定了，就不能传其他的值进去。

1
2
3
4
ArrayList<Integer> arr = new ArrayList();
arr.add(10);
arr.add(20);
arr.add("hello");//会报错

这时可以利用反射来越过泛型检查

1
2
3
4
Class<? extends ArrayList> cl = arr.getClass();
Method add = cl.getMethod("add", Object.class);
add.invoke(arr, "hello");
System.out.println(arr);//[10, 20, hello]

12.6. 反射总结

利用反射来操作类的步骤大致为以下几点

  1. 构造类的Class对象(三种方法)。
  2. 通过Class对象来获取构造器来创建实例。
  3. 通过所构造的Class对象的getMethod和getField方法来获取类的方法和成员变量。
  4. 使用返回的Field类所提供的各种方法来操作成员变量。
  5. 使用返回的Method类的invoke方法来使用所调用的方法。
  6. 如果要访问私有方法、构造器、变量，要使用setAccessible(true)。

注意事项：

  • 得到构造器、方法和字段的方法都有一个获取所有类型的方法getDeclaredXXX,可以用它来访问私有类型，不过要加上setAccessible
  • invoke的返回值为Object，因此要进行强制类型转换.

    13. 继承的设计技巧

  • 将公共操作和字段放在超类中
  • 不要使用被保护的字段
  • 使用继承实现“is-a”关系
  • 除非所有继承的方法都有意义，否则不要使用继承
  • 在覆盖方法时，不要改变预期的行为
  • 使用多态，而不用使用类型信息
  • 不要滥用反射
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

一名在校的大学生<br><br>梦想是成为一名优秀的程序员(划掉)，icer！