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

最新推荐文章于 2022-05-10 20:56:03 发布

GQYjava

最新推荐文章于 2022-05-10 20:56:03 发布

阅读量214

点赞数 1

文章标签： p2p linq c# java

本文链接：https://blog.csdn.net/GQYjava/article/details/122555399

版权

四、抽象类、抽象方法

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);

        }
    }