面向对象编程（四）继承，概念及super关键字，final关键字，Object类常见方法

继承

概念：

①   继承背后的思想就是基于已存在的类来构建新类;

②   当从已存在类继承时，就重用了它的方法和属性，还可以添加新的方法和属性来定制新类以应对需求;

③   当从其它类导出的类叫作子类，被导出的类叫作父类;

④   在Java中，除了Object类外，所有类都是子类，都有唯一父类;

⑤   继承在OO中不可或缺;

⑥   创建一个类时，总是在继承;

类之间关系：Is-a继承体现，Has-a组合体现，Like-a实现接口体现;

继承的意义：代码重用，体现不同抽象层次;

父子类关系：父类更抽象，更一般；子类更具体，更特殊;

继承的特点：1、子类继承父类的成员;2、具有层次结构;

继承的优点：1、代码重用;2、父类字段和方法可用于子类;3、从抽象到具体形成类的结构体系;4、可轻松定义子类;

 

实现:

在Java中，用extends关键字来表示一个类继承了另一个类;

public class Teacher extends Person{

         //代码

}

 

super关键字

特点：

①   Super代表父类对象的引用，this代表当前对象的引用;

②   当子父类的成员出现重名时，可以通过super来进行区分;

③   子类的构造方法中，通过super关键字调用父类的构造方法;

public class JavaTeacher extends Teacher(){

         public JavaTeacher(String name,String school){

                   //通过调用父类的构造方法，完成对相关字段值的初始化

　　　　　　super(name,school);

　　　　}

}

 

☆当构造一个类对象的时候一定会先调用父类的构造方法来构造父类的对象，调用父类的构造方法的语句必须是子类构造方法中的第一条指令;

的

public class TeacherDemo{
    public static void main(String []args){
        B b=new B();
        
        //父类中加上showB()方法之后，调用的是子类的showB();
        
        //若要调用父类的showB();在子类中加上super.showB();
        b.showB();
    }
}

class A{
    public A(){
        System.out.println("A的构造方法");
    }
    public void showA(){
        System.out.println("A");
    }
    
    public void showB(){
        System.out.println("父类中的showB方法");
    }
}

class B extends A{
    public B(){
        //super();//调用父类无参的构造方法，可以省略
        System.out.println("B的构造方法");
    }
    
    public void showB(){
        System.out.println("B");
        //showA();//子类继承父类，可以调用,同super.showA(); 因为名称未冲突
        super.showB();
        
    }
}

下面这份代码更清晰的表达了继承

public class TeacherDemo{
    public static void main(String []args){
        JavaTeacher jTeacher=new JavaTeacher("张三","清华");
        jTeacher.teaching();
        
        DBTeacher dTeacher=new DBTeacher("李四","清华");
        dTeacher.teaching();
    }
}

class Teacher{
    private String name;
    private String school;
    
    public Teacher(String name,String school){
        this.name=name;
        this.school=school;
    }
    
    public void teaching(){
        System.out.println("授课前准备");
    }
}

class JavaTeacher extends Teacher{
    public JavaTeacher(String name,String school){
        super(name,school);
    }
    
    public void teaching(){
        super.teaching();//调用父类teaching
        System.out.println("打开eclipse");
        System.out.println("书写java代码");
    }
}

class DBTeacher extends Teacher{
    public DBTeacher(String name,String school){
        super(name,school);
    }
    
    public void teaching(){
        super.teaching();//调用父类teaching
        System.out.println("打开Oracle");
        System.out.println("书写pl-sql指令");
    }
}

 final关键字

①   final可以用来修饰变量、方法、类;

②   final修饰的变量是一个常量，一旦赋了值就不能在修改。（常量一般都和static关键字配合使用）;

③   final修饰类代表此类不能被继承;

④   final修饰方法代表此类方法不能被重写;

showNumber2未加final前

public class FinalDemo{
    public static void main(String []args){
        A a=new A();
        a.showNumber1();
        
        B b=new B();
        b.showNumber2();
    }
}

class A{
    public final int number1=1;//常量
    public int number2=2;
    public void showNumber1(){
        //number1++;//不能被修改
        System.out.println(number1);
    }
    public void showNumber2(){
        System.out.println(number2);
    }
}

class B extends A{
    public void showNumber2(){
        System.out.println(number2);
    }
}

在A中的showNumber2方法中加上final报错

在A类前加上final也会报错

final用在引用变量上，代表次引用变量只能引用刚一开始所引用的变量，中途不能改变指向

public class FinalDemo{
    public static void main(String []args){
        A a=new A();
        a.showNumber1();
        
        B b=new B();
        b.showNumber2();
        
        //可以修改
        final A a2=new A();
        a2.number2=5;
        a2.showNumber2();//打印5
        
        /*a2=new A();*/ //final用在引用变量上，代表次引用变量只能引用刚一开始所引用的变量，中途不能改变指向
    }
}

//常量类不能被继承
/*final*/ class A{
    public final int number1=1;//常量
    public int number2=2;
    public void showNumber1(){
        //number1++;//不能被修改
        System.out.println(number1);
    }
    //子类不能对父类中的常量方法进行改写（重写）
    public /*final*/ void showNumber2(){
        System.out.println(number2);
    }
}

class B extends A{
    public void showNumber2(){
        System.out.println(number2);
    }
}

Object类常见方法

Java中，所有类都直接或间接继承自java.lang.Object类，可以说Object是java中所有类的祖先即根类;

Java中任何类都继承了Object类中的方法，只要有toString(),equals(),hashcode(),clone(),getClass(),finalizw()

 

String toString()

①   返回该对象的字符串描述性信息。默认输出的格式是：类名[字段值,字段值…];

②   只要对象与一个字符串通过“+”连接，系统就自动调用toString()以获得对象的字符串描述;

③   常被改写，可以根据用户的需求对其进行重写;

 

boolean equals()

①   Object类原始功能是实现判断两个对象是否具有相同引用；要求判断两个对象状态的相等性;

②   在jdk标准库中提供了一些类，比如String，Date都对equals方法进行了重写;

③   常被改写，可以根据用户的需求对其进行重写;

public class ObjectDemo{
    public static void main(String []args){
        Student stu1=new Student("张三",20);
        System.out.println(stu1);//打印对象 输出Student@2a139a55   @之前是类名，之后是哈希码（可以认为是堆内存中的地址）
        
        System.out.println(stu1.toString());
        //未重写toString()之前 输出与以上内容相同，但Student中未编写toString()方法，
        //也可以使用是因为它默认继承了Object类，该类中有toString()方法
        //重写toString()之后，输出内容为重写之后的内容
        
        Student stu2=new Student("张三",20);
        
        //未重写equals()方法之前
        System.out.println(stu2.equals(stu1));//输出false，不是指向同一个对象
        System.out.println(stu2.equals(stu2));//输出true
        //重写equals方法之后，如下则全部输出true
    }
}

//加上与不加上继承Object是一样的，默认就会继承
class Student /*extends Object*/{
    private String name;
    private int age;
    
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    
    //重写Object中的toStirng()方法
    public String toString(){
        return "姓名:"+name+",年龄:"+age;
    }
    
    
    //重写equals方法
    public boolean equals(Object obj){
        //自己与自己比
        if(this==obj){
            return true;
        }
        if(obj==null)
        {
            return false;
        }
        if(this.getClass()!=obj.getClass())
        {
            return false;
        }
        
        Student stu=(Student)obj;
        if(this.age!=stu.age)
        {
            return false;
        }
        if(this.name==null)
        {
            if(stu.name!=null)
            {
                return false;
            }
        }
        else if(!this.name.equals(stu.name)){
            return false;
        }
        
        return true;
    }
}