Java 面向对象知识点整理

zhong1990
1,563 阅读5分钟

不定期更新，欢迎指正

1. 重载、重写和隐藏

1). 重载(overload)：

方法重载就是多个方法名称相同但是参数类型或者参数个数不同的方法，与返回值类型和修饰符无关

class Test {
    public int test(int a) {
        return a;
    }

    public String test(String a) {
        return a;
    }

    public float test(int a, String b) {
        return 0f;
    }

    public float test(String a, int b) {
        return 1.0f;
    }

    String test(float a) {
        return "";
    }

    String test(int a) {//该方法不是重载  
        return "";
    }
}

前面五个互为重载，第一个和第六个虽然返回值类型不同，但参数相同，所以第一个和第六个参数不是重载

2). 重写(override):

子类继承父类时，子类的方法名称、参数类型、参数个数与父类完全相同，则认为子类重写了父类的方法。

方法重写规则：

  • 参数列表和原方法完全相同
  • 返回值类型和原方法相同或者为父类返回值类型的子类型
  • 不能比原方法限制更严格的访问级别(举例：父类方法为public，那么子类不能为protected、private)
  • 父类方法被定义为final时，则不能被重写
  • 父类方法被定义为static时，不能被重写，但是可以重写声明一个相同的方法（参考隐藏）
  • 不能抛出新的异常或比原方法更广泛的异常（父类抛出IOException，重写方法不能抛出Exception只能抛出IOException或者IOException子类异常）
3). 隐藏:

隐藏是针对于父类的成员变量和静态方法而言的。子类中声明了和父类相同的变量名或静态方法(方法名相同、参数列表相同、返回类型相同)则实现了对父类成员变量和静态方法的隐藏，下面举个例子有助理解：

class A {  
    static int a = 1;  
    static int b = 2;  
    int c = 33;

    public static void printA() {  
        System.out.print(a);  
    }  

    public static void printB() {  
        System.out.print(b);  
    }  

}

class B extends A {  
    static int a = 3;  
    static int b = 4;
    int c = 44;

    public static void printB() { 
        System.out.print(b);  
    }  
}

public class Test {  
    public static void main(String[] args) {  
        B.printA();
        B.printB();
        System.out.print(B.a);  

        A a = new B();
        B b = new B();

        a.printB();
        b.printB();
        System.out.print(a.c);
        System.out.print(b.c);
    }  
}  

输出结果：
1 4 3 2 4 33 44

如果子类中有相同名称的静态方法或变量父类的会被隐藏，如果子类中存在同名的静态方法或变量，则会隐藏父类中得静态方法或变量，此时子类调用的就是子类中自己的静态方法或变量；如果子类中不存在同名的静态方法或变量，则会调用父类中的静态方法或变量；父类调用的始终是其本身的静态方法和变量。

2. 封装：

封装是把对象的属性和操作结合为一个独立的整体，隐藏对象内部操作的实现，用户只需要通过其对外提供的方法来访问该对象，无需知道其内部实现细节。

优点：

  • 隐藏内部实现细节，提供公共访问方式
  • 类内部可以自由修改不影响其调用者
  • 减少耦合度，提高安全性

3. 继承：

继承是一个对象获取另一个对象属性的过程，关键字为extends和implements。

1). IS-A关系(一个对象所属于另一个对象)：
方式一. 用extends来实现继承：
public class Animal {
    public void eat() {
        System.out.println("Animal eating...");
    }
}

public class Mammal extends Animal {
    public void eat() {
        System.out.println("Mammal eating...");
    }
}

public class Dog extends Mammal {
    public void eat() {
        System.out.println("Dog eating...");
    }
}
方式二. 用implements来实现继承：
public interface Animal {
    void eat();
}

public class Mammal extends Animal {
    public void eat() {
        System.out.println("Mammal eating...");
    }
}

public class Dog extends Mammal {
    public void eat() {
        System.out.println("Dog eating...");
    }
}

无论方式一还是方式二，我们都可以用instanceof关键字检查得出：Mammal是一个Animal(哺乳动物也是动物)；Dog既是一个Mammal，也是一个Animal(狗既是哺乳动物也是动物)。

public class Test {  
     /**
       * instanceof关键字检查代码
      */
    public static void main(String[] args) {
        Mammal m = new Mammal();
        Dog d = new Dog();
        System.out.print(m instanceof Animal);
        System.out.print(d instanceof Mammal);
        System.out.print(d instanceof Animal);
    }
}

输出结果：
true true true
2). HAS-A关系(一个对象含有另一个对象的一些属性)：
public class Car{}

public class Speed{}

public class Benz extends Car{
    private Speed sp; 
}

Benz含有Spend属性，但Benz不是Spend

4. 多态：

实现多态的三个必要条件：继承、重写、父类引用指向子类对象。

1). 向上转型：

我们实例化一个Dog对象可以用 Dog d = new Dog(); 我们也可以用 Animal d = new Dog();，后者就是向上转型(父引用指向子对象)，上面两种方式创建出来的对象d，调用d.eat();输出的结果都是Dog eating...，这就体现出了java得多态。向上转型创建的对象会遗失掉和父类不同的方法和变量(不能用来调用子类特有的方法和变量)。

2). 举例说明：
class A {
    public String show(D obj) {
        return ("A and D");
    }

    public String show(A obj) {
        return ("A and A");
    }
}

class B extends A {
    public String show(B obj) {
        return ("B and B");
    }

    public String show(A obj) {
        return ("B and A");
    }
}

class C extends B {}

class D extends B {}

class Test {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();
        System.out.println(a1.show(b)); //  ①
        System.out.println(a1.show(c)); //  ②
        System.out.println(a1.show(d)); //  ③
        System.out.println(a2.show(b)); //  ④
        System.out.println(a2.show(c)); //  ⑤
        System.out.println(a2.show(d)); //  ⑥
        System.out.println(b.show(b));  //  ⑦
        System.out.println(b.show(c));  //  ⑧
        System.out.println(b.show(d));  //  ⑨
    }
}

输出结果：
A and A    //  ①
A and A    //  ②
A and D    //  ③
B and A    //  ④
B and A    //  ⑤
A and D    //  ⑥
B and B    //  ⑦
B and B    //  ⑧
A and D    //  ⑨

前三个比较简单不容易出错，看看下面几个：

  • ④：a2是A的引用指向B对象，向上转型创建的对象会遗失掉和父类不同的方法和变量，所以a2只能调用show(D obj)、show(A obj)两个方法，所以a2.show(b)应该调用show(A obj)方法，B中重写了该方法，所以运行时JVM会调用B类中重写的show(A obj)方法，所以输出B and A；
  • ⑤: 原理同④；
  • ⑥：a2.show(d)应该调用show(D obj)方法，B中没有重写该方法所以调用的为A类中的该方法，所以输出为A and D;
  • ⑦⑧⑨：b为B类对象，可调用A类中show(D obj)、B类中show(B obj)、B类中show(A obj)方法，所以输出如上。
avatar
文章
阅读
粉丝