抽象类，抽象方法，final，object类

四、抽象类、抽象方法

1、课堂Demo【重点掌握】

父类 Pet.java

    package netclass04.abstracts;
     
  
    public abstract class Pet {
     
        private String name;
        private int age;
     
        public Pet(){
     
        }
     
        public Pet(String name,int age){
            this.name = name;
            this.age = age;
        }
     
        //抽象方法
        public abstract void print();
     
        public void show(){
            System.out.println("Pet show... ...");
        }
     
    }

子类 Dog.java

    package netclass04.abstracts;
     
 
    public class Dog extends Pet{
     
        private String gender;
     
        @Override
        public void print() {
            System.out.println("dog print... ...");
        }
    }

测试类 PetTest.java

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

五、final

1、课堂Demo【重点掌握】

FinalDemo.java

    package netclass04.abstracts;
     
  
    /*
     * final的使用：
     *       final可以修饰变量：
     *               表示变量的值不可变
     *       final可以修饰方法：
     *               表示方法不可以被重写
     *       final可以修饰类：
     *               表示类不可以被继承
     *
     *
     */
    public /*final*/ class FinalDemo {
     
        private String name;
     
    //    public FinalDemo(){
    //        super();
    //    }
     
        public String getName() {
            return name;
        }
     
        public void setName(String name) {
            this.name = name;
        }
     
        public static final int num = 10;
     
        public final void show(){
            System.out.println("FinalDemo... ...");
        }
     
        public static void main(String[] args) {
    //        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{
     
    //    @Override
    //    public void show(){
    //
    //    }
     
    }

六、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) {
        return (this == obj);
    }

4、Object课堂Demo【重点掌握】

    package netclass04.abstracts;
     
    import java.util.Objects;
     
  
    public class Teacher{
     
        private String name;
        private int age;
        private double salary;
     
        public Teacher() {
        }
     
        public Teacher(String name, int age, double salary) {
            this.name = name;
            this.age = age;
            this.salary = salary;
        }
     
        public String getName() {
            return name;
        }
     
        public void setName(String name) {
            this.name = name;
        }
     
        public int getAge() {
            return age;
        }
     
        public void setAge(int age) {
            this.age = age;
        }
     
        public double getSalary() {
            return salary;
        }
     
        public void setSalary(double salary) {
            this.salary = salary;
        }
     
    //   @Override
    //   public boolean equals(Object o){
    //        Teacher t =(Teacher) o;
    //        return (this.name == t.name && this.age == t.age && this.salary == t.salary);
    //   }
     
     
        @Override
        public boolean equals(Object o) {
            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() {
            return Objects.hash(name, age, salary);
        }
     
        @Override
        public String toString() {
            return "Teacher{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", salary=" + salary +
                    '}';
        }
     
        //    @Override
    //    public String toString(){
    //        return "name:" +this.name +" age:" +this.age +" salary:" + this.salary;
    //    }
     
        public static void main(String[] args) {
            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，然后再依次向下执行类的初始化块和构造方法，直到当前子类为止。