Java个人学习笔记--继承-原创手记-慕课网

1. java中的继承
a. 子类可以继承父类的属性和方法。
语法规则：
class 子类 extends 父类；
例子：

public class Chinese extends People {

}

b.父类中的private属性无法被子类继承。代码中如果出现子类使用父类的private属性，会提示语法错误。

2. 方法重写
a. 子类对父类方法不满意可以重写，调用时优先调用子类中的方法。
b. 方法重写注意：返回值类型、方法名、参数及个数都要与父类继承的方法相同。

3. 继承的初始化顺序
a.在创建子类对象时，先初始化父类对象再初始化子类对象（构造方法的执行顺序）。
b. 类中属性的初始化顺序：先执行初始化对象中属性，在执行构造方法中的初始化。
例子：


public class People {
    public int age=18;
    public String name;
    public char sex;
    public void speak(){
        System.out.println("People can speak!");
        System.out.println(name+"  "+age+"岁"+"  "+sex);
    }
    public People(){
        age=20;
        System.out.println("People 类执行了");
    }

}

最终age的结果是20，因为先执行了age=18，后执行了构造函数中的age=20，所以最终20覆盖掉了原来的值。
--总结一下执行顺序：--
图片描述

4. final关键字
final关键字可以修改类，方法、属性和变量。
注意：
a. final修饰类，则该类不允许被继承。
b. final 修饰方法，则该方法不允许被重写。
c. final修饰属性，则该类的属性不会进行隐式的初始化（即系统不会自动给出默认初始值），初始值不允许被改变。
d. final修饰属性，则该类的属性初始值可以在定义时给出初始值，或者在构造函数中给出初始值，二者只能选其一。
e. final修饰的变量，则该变量只能赋值一次，即变为常量。

//final修饰的属性初始化后不能被修改
public class People {
    final public int age=18;//final 修饰的属性只能在定义时给出初始值，或者在构造函数中给出初始值，二者只能选其一
    public String name;
    public char sex;
    public void speak(){
        System.out.println("People can speak!");
        System.out.println(name+"  "+age+"岁"+"  "+sex);
    }
    public People(){
        age=20;//final修饰的属性不允许被修改，age定义时已给出初始值，该行代码age=20应该删掉。
        System.out.println("People 类执行了");
    }

}

final修饰的属性定义时没有赋值，可以在构造函数中赋值：

//修饰的属性只能在定义时给出初始值，或者在构造函数中给出初始值，二者只能选其一
public class People {
    final public int age;//final 修饰的属性只能在定义时给出初始值，或者在构造函数中给出初始值，二者只能选其一
    public String name;
    public char sex;
    public void speak(){
        System.out.println("People can speak!");
        System.out.println(name+"  "+age+"岁"+"  "+sex);
    }
    public People(){
        age=20;//final修饰的属性可以在构造函数中赋值初始化。
        System.out.println("People 类执行了");
    }

final修饰的属性，不支持系统默认初始值，即不能定义时不给赋值，也不在构造函数中赋值。

5. super的使用、
super 关键字，在对象的内部使用，可以代表父类对象。
访问父类属性，如：super.age;
访问父类方法，如：super.speak();

当创建子类对象时会自动调用父类的构造方法，并且创建父类对象。
a. 如果子类的构造方法中没有显示调用父类构造方法，则系统默认调用父类午参构造方法。
b.如果子类的构造方法中有显示调用父类构造方法，则必须在子类的构造方法的第一行。（否则会报语法错误）
c.如果子类构造方法中么有显示调用父类构造方法，而父类中有没有无参构造方法，则编译出错。（一个类中如果给出一个有参的构造函数，那么系统不会再自动给一个无参构造函数）

6. Object类
Object类是所有类的父类，如果一个类没有使用extends关键字明确标识继承另外一个类，那么这个类默认继承Object类。
Object类中的方法适合所有子类。如，toString()方法和equals()方法
a. toString()方法
Object类中的toString()方法是返回对象的哈希码（即，对象的地址字符串）。
可以通过重写toString()方法，来返回对象的属性值。
b. 重写toString()方法
eclipse可以自动帮我们重写toString()方法，通过菜单栏的【Source】--【Generate toString()...】,再Generate toString()对话框中选择要继承的属性， OK。则toString()方法会自动写好。
例如：

public class People {
    public int age;
    public String name;
    public char sex;
    public void speak(){
        System.out.println("People can speak!");
        System.out.println(name+"  "+age+"岁"+"  "+sex);
    }
    public People(){
        System.out.println("People 类执行了");
    }

public class Chinese extends People {
    public Chinese(){
        System.out.println("Chinese类执行了");
    }

    @Override
    public String toString() {
        return "Chinese [age=" + age + ", name=" + name + ", sex=" + sex + "]";
    }//重写的toString()方法，返回对象的所有属性值。

}

public class testPeople {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        People test= new People();
        System.out.println("people age:"+test.age);
        Chinese zhang = new Chinese ();
        zhang.age=18;
        zhang.sex='女';
        zhang.name="张三";
        zhang.speak();
        System.out.println(zhang);//调用类Chinese中的toString()方法，返回其属性值

    }

}

该toString()方法返回值应该是Chinese [age=18, name=张三, sex=女]
以上程序输出：

People 类执行了
people age:0
People 类执行了
Chinese类执行了
People can speak!
张三  18岁  女
Chinese [age=18, name=张三, sex=女]

c. equals()方法
比较的是对象的引用是否指向同一块内存地址。
如：Chinese zhang = new Chinese();
创建了zhang这个对象，其中zhang实际上是内存中的地址。
例子：

                Chinese zhang = new Chinese();
                Chinese wang = new Chinese();
        if(zhang.equals(wang)){
            System.out.println("两个对象指向同一个内存地址");
        }else{System.out.println("两个对象指向不同的内存地址");}

结果：两个对象指向不同的内存地址

d.equals()方法重写
比较两个对象时常常是比较她的值是否一致，所以要进行重写。
eclipse中的菜单栏的【Source】--【Generate hashCode() and equals()...】
注意：需要重写那个类的equals就要在哪个类中重写。通过这个菜单会自动插入hashCode() 和equals()两个重写函数，如果不需要hashCode()，可以删除，只留equals()。
（个人经验：

-需要重写equals()的类中必须定义了自己的属性，否则无法插入。即使父类中已有属性的定义，也要再子类中重新定义一遍。
-把需要进行比较的属性都要在子类中进行重新定义一遍，才能根据属性自动插入完整的equals()方法）
例子：

public class People {
    public int age;
    public String name;
    public char sex;
    public void speak(){
        System.out.println("人类能说话!");
    }
    public People(){
        age=20;
        System.out.println("People 类执行了");
    }

}
public class Chinese extends People {
    //后面要重写equals()，所以需要自己在定义一遍属性（个人经验）
    int age=30;
    String name;
    char sex;
    public Chinese(){
        System.out.println("Chinese类执行了");
    }
    public void speak(){
        System.out.println("中国人能说多国语言");
    }
    public void method(){
        System.out.println(super.age);//输出父类的属性age值
        System.out.println(age);//输出子类属性age值
        super.speak();
        speak();
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Chinese other = (Chinese) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (sex != other.sex)
            return false;
        return true;
    }
    @Override
    public String toString() {
        return "Chinese [age=" + age + ", name=" + name + ", sex=" + sex + "]";
    }//重写的toString()方法，返回对象的所有属性值。
public class testPeople {

    public static void main(String[] args) {

        //定义两个Chinese对象，用于后面的比较equals（）
        Chinese zhang = new Chinese ();//创建一个子类时，会先之星父类构造函数，再执行子类构造函数
        Chinese wang = new Chinese();

        //下面给两个对象的属性赋值
        zhang.age=18;
        zhang.sex='女';
        zhang.name="张三";
        wang.age=18;
        wang.sex='女';
        wang.name="王五";
        zhang.method();
        System.out.println(zhang);//输出对象zhang的值（toSting返回的值）
        System.out.println(wang);//输出对象wang的值（toSting返回的值）
        //比较两个对象的引用是否相同
        if(zhang.equals(wang)){
            System.out.println("两个对象是相同的");
        }else{
            System.out.println("两个对象是不同的");
            }
    }

}

输出结果：

People 类执行了
Chinese类执行了
People 类执行了
Chinese类执行了
20
18
人类能说话!
中国人能说多国语言
Chinese [age=18, name=张三, sex=女]
Chinese [age=18, name=王五, sex=女]
两个对象是不同的

分析下重写的equals():

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;//判断两个对象的引用是否是指向同一个地址，如果是指向同一个地址，那么一定是相同的对象，返回true。
        if (obj == null)
            return false;//判断另一个对象的引用是否为空，如果为空返回false，不用再判断了。
        if (getClass() != obj.getClass())//getClass()方法是返回对象的类型。
            return false;//判断两个队形的类型是否相同，如果对象类型不同，那么肯定是不同的对象。
        Chinese other = (Chinese) obj;//将传进的对象obj转化为Chinese类型，转化为相同类型收，下面进行属性比较。
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (sex != other.sex)
            return false;
        return true;
    }