Java面向对象核心知识（二）

朴灿烈づ我的快乐病毒、 2022-01-13 12:17 340阅读 0赞

# Java面向对象核心知识（二） #

[Java面向对象核心知识（一）][Java]

### 文章目录 ###

*  Java面向对象核心知识（二）
 *   *  一、方法的重写（overwrite/override）
     *  二、super关键字
     *  三、继承中的构造方法
     *  四、Object类
     *  五、toString方法（Object中其中的一个方法）
     *  六、equals方法（也是Object类中的一个方法）
     *  七、对象转型（casting）—— 程序的可扩展性得到了很大的提高
     *  八、动态绑定（多态）—— 程序的可扩展性达到极致
     *  九、抽象类
     *  十、final关键字
     *  十一、接口（interface）
     *  十二、总结

## 一、方法的重写（overwrite/override） ##

1.  在子类中可以根据需要从父类中继承来的方法进行重写
2.  重写方法必须要和被重写方法具有相同的方法名称、参数列表和返回值类型。
3.  重写方法不能使用比被重写方法更严格的访问权限。
4.  当需要重写一个方法时，要去copy，以免出错！
5.  重写和重载的区别。方法重新实现了动态多态性（也称为动态联编），方法重载则实现了静态多态性（编译时多态）。也正是重写和重载体现了Java的多态性。

## 二、super关键字 ##

**在Java类中使用super来引用父类的东西**

1.  当new一个对象出来的时候会有一个this引用，这个this指向这个对象自身。
2.  如果这个对象是一个子类对象的话，那么，还会有另外的一个引用，叫super，super指向当前对象里面的父对象。
3.  使用super.方法名调用父类中的方法
4.  一个子类对象new出来的时候，在这个子类对象内部是有一个父类对象的。

## 三、继承中的构造方法 ##

1.  在子类的构造过程中必须调用其父类的构造方法，或者说必须在子类中重写构造方法，因为构造方法不能继承。
2.  子类可以在自己的构造方法中使用super（参数列表）调用其父类的构造方法；使用this（参数列表）调用本类的另外的的构造方法，如果调用super，则必须写在子类构造方法的第一行。
3.  如果子类的构造方法中没有显式调用父类的构造方法，则系统默认使用父类无参数构造方法。
4.  如果子类构造方法中既没有显式调用父类构造方法，而父类中又没有无参的构造方法，则编译出错！

## 四、Object类 ##

1.  Object类是所有Java类的根基类
2.  如果在类的声明中未使用extends关键字指明父类，则默认父类为Object类  
    例如：

public class Person{
          ....   
     }

等价于

public class Person extends Object{ 
           ....  
    }

## 五、toString方法（Object中其中的一个方法） ##

1.  Object类中定义有public String toString（）方法，其返回值是String类型，此方法用于描述当前对象的有关信息，默认描述格式：类名加其所在的内存地址（类@地址）
2.  在进行String与其他类型数据的连接操作时，将自动调用该对象的toString（）方法，例如：`System.out.println("info" + person);`
3.  可以根据需要在用户自定义类型中重写toString（）方法。
4.  **补充**：“==”比较的是两个对象的内存地址，而equals则比较的是二者是否指向同一个对象。

## 六、equals方法（也是Object类中的一个方法） ##

1.  Object类中定义有：`public boolean equals(Object obj)`方法，提供定义对象是否“相等”  
    的逻辑。
2.  Object的equals方法定义为：x.equals(y)，当x和y是同一个对象的引用时返回true，否则返回false。
3.  JDK提供的一些类，如String，Date，Integer等，重写了Object的equals方法，调用这些类的equals方法，x.equals(y)，当x和y所引用的对象是同一类对象且属性内容相等时（并不一定是相同对象），返回true，否则返回false。
4.  可以根据需要在用户自定义类型中重写equals方法。

## 七、对象转型（casting）—— 程序的可扩展性得到了很大的提高 ##

1.  一个父类的引用类型变量可以“指向”其子类的对象。（如：`Father father = new Son()；`）
2.  一个父类的引用不可以访问其子类对象新增加的成员变量和方法。
3.  可以使用引用变量instanceof类名来判断该引用类型变量所“指向”的对象是否属于该类或者该类的子类。
4.  子类的对象可以当作父类的对象来使用，称作向上转型（upcasting），反之称为向下转型（downcasting）。
5.  父类引用指向子类对象时，它看到的只是作为父类的那部分所拥有的属性和方法，至于子类那部分是“看”不到的，但是它仍属于子类类型。例如： `animal instanceof Dog; //true`
6.  在发生向下转型之前，一定要首先发生对象的向上转型，建立关系后才可以进行。例如：

Animal animal = new Dog("bigyellow","yellow"); //通过向上转型建立关系
    Dog dog1 = (Dog) animal; //向下转型
    System.out.println(dog1.furColor);

1.  父类引用可以指向子类对象，从而程序可扩展性得到了很大的提高，我们可以在一个方法参数里面定义父类的引用，然后实际传的时候是子类对象，这个时候在实现方法时，判断到底属于哪个子类，然后再执行里面的方法或者调用里面的成员变量。

## 八、动态绑定（多态）—— 程序的可扩展性达到极致 ##

1.  动态绑定是指“在执行期间(非编译期间)”判断所引用对象的实际类型，根据实际的类型调用其相应的方法。new出来的是谁，就找谁的方法。
2.  下面的例子中，根据Lady对象的成员变量pet所引用的不同的实际类型而调用相应的enjoy方法。

package com.lfq.faceobject.testcast;
    
    /**
     * 多态（动态绑定）
     * 程序的可扩展性发展到极致
     */
    public class TestDuoTai {
    
        public static void main(String[] args) {
            Cat2 cat2 = new Cat2("cat2Name", "blue");
            Dog2 dog2 = new Dog2("dog2Name", "black");
            Lady lady1 = new Lady("laydy1", cat2);
            Lady lady2 = new Lady("lady2", dog2);
            lady1.mypetEnjoy();
            lady2.mypetEnjoy();
        }
    
    }
    
    class Animal2 {
        private String name;
    
        Animal2(String name) {
            this.name = name;
        }
    
        public void enjoy() {
            System.out.println("叫声......");
        }
    }
    
    class Cat2 extends Animal2 {
        private String eyesColor;
    
        Cat2(String name, String eyesColor) {
            super(name);
            this.eyesColor = eyesColor;
        }
    
        public void enjoy() {
            System.out.println("猫叫声......");
        }
    }
    
    class Dog2 extends Animal2 {
        private String furColor;
    
        Dog2(String name, String furColor) {
            super(name);
            this.furColor = furColor;
        }
    
        public void enjoy() {
            System.out.println("狗叫声......");
        }
    }
    
    class Lady {
        private String name;
        private Animal2 pet;
    
        Lady(String name, Animal2 pet) {
            this.name = name;
            this.pet = pet;
        }
    
        public void mypetEnjoy() {
            pet.enjoy();
        }
    }

程序运行结果如下：  
![运行结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70]核心机制：调用方法时，只要这个方法重写了，实际调用哪个方法，要看你实际当中new的是什么对象，这个机制就叫多态机制或者动态绑定，也称为延迟绑定，这个机制是面向对象的核心机制。

1.  多态的总结  
    多态的存在必须的三个条件：
    
     *  要有继承或者类实现接口
     *  要有重写或者对接口方法的实现
     *  父类引用指向子类对象或者接口对象指向它的实现类  
        这三个条件一旦满足，当你调用父类里面被重写的方法或者调用你实现接口的方法的时候，实际当中new的是哪个子类对象就调用子类对象的那个方法。

## 九、抽象类 ##

1.  继承抽象类的类一般应该实现抽象类中的所有抽象方法，如果没有，那么该子类也应该声明为抽象类。
2.  用abstract关键字来修饰一个类时，这个类叫做抽象类，用abstract来修饰一个方法时，该方法叫做抽象方法。
3.  含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写。
4.  抽象类不能被实例化，即不能new对象
5.  抽象方法只需声明，而不需要实现。
6.  抽象方法就是被用来重写的，所以在子类里面应该重写这方法。
7.  抽象方法的一个主要目的就是为所有子类定义一个统一的接口。
8.  抽象类不一定要包含抽象方法。若类中包含了抽象方法，则该类必须被定义为抽象类。
9.  抽象类的子类必须覆盖所有的抽象方法后才能被实例化，否则这个子类还是个抽象类。

## 十、final关键字 ##

1.  final的变量的值不能够被改变，包括final的成员变量，final的局部变量。例如：形式参数
2.  final的类不能够被继承，即不能有子类。
3.  final的方法不能够被重写。
4.  final常量：常量必须赋初值，即初始化可在定义处或构造方法中，而且不能再发生变化。

## 十一、接口（interface） ##

1.  接口是抽象方法和常量值的定义的集合。。
2.  从本质来讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。
3.  接口定义，例如：

public interface Runner{
    		public static final int id = 1;
    		public abstract void start();//public和abstract写不写都行，默认就是public和abstract的
    		public void run();
    		public void stop();
    }

1.  多个无关的类可以实现同一个接口。
2.  一个类可以实现多个无关的接口。
3.  与继承关系类似，接口与实现类之间存在多态性
4.  定义Java类的语法格式：

<modifier> class <name> [extends <superclass>] [implements <interface>] [,<interface>...]{
    	<declarations>*
    }

**接口特性：**

*  接口可以多重实现，也就是一个类可以实现多个接口。
 *  接口中声明的属性默认为public static final的，也只能是public static final的。
 *  接口中只能定义抽象方法，而且这些方法默认为public的，也只能是public的。
 *  接口可以继承其他的接口，并添加新的属性和抽象方法。
 *  接口之间可以相互继承，一个类只能实现接口，类和类之间可以继承，接口和接口之间也可以相互继承，但是类和接口之间，只能是类实现接口。

## 十二、总结 ##

1.  Java程序运行的内存分析至关重要
2.  对象和类的概念
3.  类和类之间的关系，类和对象之间的关系
4.  面向对象设计思想
5.  class
6.  new和引用的概念；构造方法的概念
7.  方法重载；构造方法重载
8.  this
9.  static
10. package和import
11. private/default/protected/public
12. extends
13. overwrite/override
14. final
15. Object toString/equals
16. upcasting/downcasting
17. 多态

[Java]: https://blog.csdn.net/Mysky984/article/details/91471633
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70]: /images/20220113/f4b85af0626c47459e2a1fad262e360d.png