抽象类，抽象方法，final，Object

四、抽象类、抽象方法
 

父类 Pet.java

package netclass04.abstracts;
 

public abstract class Pet {undefined
 
    private String name;
    private int age;
 
    public Pet(){undefined
 
    }
 
    public Pet(String name,int age){undefined
        this.name = name;
        this.age = age;
    }
 
    //抽象方法
    public abstract void print();
 
    public void show(){undefined
        System.out.println("Pet show... ...");
    }
 
}
子类 Dog.java

package netclass04.abstracts;
 

public class Dog extends Pet{undefined
 
    private String gender;
 
    @Override
    public void print() {undefined
        System.out.println("dog print... ...");
    }
}
测试类 PetTest.java

package netclass04.abstracts;
 

 
 
/*
 * java中的对象是对现实世界的具象化，但是在现实世界中，某些类并不具备实例化的意义，因此可以定义为抽象类
 *
 * 抽象类：
 *       1、创建抽象类的时候需要添加 abstract 的关键字
 *       2、不能进行实例化，也就是不能new对象
 *       3、抽象类中的某些方法需要子类进行更丰富的实现，父类实现没有意义，此时可以将抽象类
 *             中的方法定义为抽象方法，没有具体的实现，只包含方法名称，返回值，参数列表，访问修饰符
 *       4、使用abstract关键字修饰的方法叫做抽象方法，可以不写方法的实现
 *       5、子类在继承抽象父类的时候，必须要将父类中的抽象方法进行实现或者将子类也定义为抽象类
 *       6、有抽象方法的一定是抽象类，但是抽象类中不一定包含抽象方法
 *
 */
public class PetTest {undefined
 
    public static void main(String[] args) {undefined
        Dog dog = new Dog();
        dog.print();
//        Pet pet = new Pet();
    }
 
}
五、final
 

FinalDemo.java

package netclass04.abstracts;
 

 
/*
 * final的使用：
 *       final可以修饰变量：
 *               表示变量的值不可变
 *       final可以修饰方法：
 *               表示方法不可以被重写
 *       final可以修饰类：
 *               表示类不可以被继承
 *
 *
 */
public /*final*/ class FinalDemo {undefined
 
    private String name;
 
//    public FinalDemo(){undefined
//        super();
//    }
 
    public String getName() {undefined
        return name;
    }
 
    public void setName(String name) {undefined
        this.name = name;
    }
 
    public static final int num = 10;
 
    public final void show(){undefined
        System.out.println("FinalDemo... ...");
    }
 
    public static void main(String[] args) {undefined
//        FinalDemo fd = new FinalDemo();
//        fd.num = 20;
//        FinalDemo.num = 20;
//        num = 20;
//        System.out.println(num);
        final FinalDemo fd = new FinalDemo();
        fd.show();
//        fd = new FinalDemo();
        fd.setName("jason");
        System.out.println(fd.getName());
 
    }
 
}
FinlaSubClass.java

package netclass04.abstracts;
 

public class FinalSubClass extends FinalDemo{undefined
 
//    @Override
//    public void show(){undefined
//
//    }
 
}
六、Object类
1、Object类是所有类的父类

        一个类如果没有使用extends显性的继承另外一个类，那么这个类就继承自Object类。

2、源码解析（涉及到Object中常用的10个方法）

 getClass()、hashCode()、equals(Object)、clone()、toString()、notify()、notifyAll()、wait()、wait(long)、wait(long,int)

finalize()方法为过时的方法或者说是不推荐的方法，主要作用是标识在堆中的对象哪些是没有被引用的，方便JVM中的GC进行垃圾回收。

3、对象的比较—==和equals()

a、==：

        ---- 比较两基本类型变量的值是否相等

        ---- 比较两个引用类型的值即内存地址是否相等，即是否指向同一对象。

b、equals() ：

        两对象的内容是否一致

c、自定义类须重写equals()，否则其对象比较结果总是false。

        通过阅读Object源码可知，equals()方法的实现是用==完成的

Object源码摘抄

public boolean equals(Object obj) {undefined
    return (this == obj);
}
4、Object课堂Demo【重点掌握】

package netclass04.abstracts;
 
import java.util.Objects;
 

 */
public class Teacher{undefined
 
    private String name;
    private int age;
    private double salary;
 
    public Teacher() {undefined
    }
 
    public Teacher(String name, int age, double salary) {undefined
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
 
    public String getName() {undefined
        return name;
    }
 
    public void setName(String name) {undefined
        this.name = name;
    }
 
    public int getAge() {undefined
        return age;
    }
 
    public void setAge(int age) {undefined
        this.age = age;
    }
 
    public double getSalary() {undefined
        return salary;
    }
 
    public void setSalary(double salary) {undefined
        this.salary = salary;
    }
 
//   @Override
//   public boolean equals(Object o){undefined
//        Teacher t =(Teacher) o;
//        return (this.name == t.name && this.age == t.age && this.salary == t.salary);
//   }
 
 
    @Override
    public boolean equals(Object o) {undefined
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Teacher teacher = (Teacher) o;
        return age == teacher.age &&
                Double.compare(teacher.salary, salary) == 0 &&
                Objects.equals(name, teacher.name);
    }
 
    @Override
    public int hashCode() {undefined
        return Objects.hash(name, age, salary);
    }
 
    @Override
    public String toString() {undefined
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
 
    //    @Override
//    public String toString(){undefined
//        return "name:" +this.name +" age:" +this.age +" salary:" + this.salary;
//    }
 
    public static void main(String[] args) {undefined
        Teacher t1 = new Teacher("张飞",28,9000);
//        Teacher t2 = t1;
        Teacher t2 = new Teacher("张飞",28,9000);
//        System.out.println(t1 == t2);//true    false
//        t2.setName("赵云");
        System.out.println(t1.equals(t2));//true   false
        System.out.println(t1);
 
    }
}
七、总结
1、继承深化

a、父类方法的重写：

        ---- 方法名、形参列表相同。

        ---- 返回值类型和异常类型，子类小于等于父类。

        ---- 访问权限，子类大于等于父类

b、构造方法调用顺序：

        ---- 根据super的说明，构造方法第一句 总是：super(…)来调用父类对应的构造方法。

        ---- 先向上追溯到Object，然后再依次向下执行类的初始化块和构造方法，直到当前子类为止。