Java学习日记 | Abstract | Interface | Object

1.Abstract

        1.1 Abstact 是什么

        abstract 是修饰符,表示抽象的,用来修饰抽象类和抽象方法

        abstract修饰的类是抽象类,并且抽象类不能创建对象,而且抽象类一般主要是用于被继承

子类如果继承了抽象类,那么需要实现所有的抽象方法,否则该子类就需要使用abstract修饰

        普通类继承抽象类需要实现所有抽象方法

        抽象类继承抽象类,需要实现0~N个抽象方法

        abstract修饰的方法是抽象方法,并且该方法没有方法体,就可以看做是没有方法体的成员方法,只定义功能,不定义实现,用于让不同的子类去实现(覆写)

        抽象方法,必须在抽象类中,而抽象类中可以没有抽象方法

        抽象类可以看做特殊的类,类能做的它都能做,只不过,不能创建对象,可以有抽象方法而已

        abstract  和 final 不能同时出现

        1.2 使用语法

//抽象类

         abstract class Sup{
                //抽象方法
                public abstract void m1();
                public void m2(){
                }
        }
        class Sub1 extends Sub{
                @override
                public void m1(){
                }
        }
        abstract class Sub2 extends Sub{
        }
        //不能创建对象
        //Sub sub = new Sub();
        //abstract 和 final 不能同时出现
        //abstract final class A{}

2. Interface

        2.1 Interface 是什么

        Interface : 定义接口的关键字 

        JDK1.8之前,接口是完全抽象的,只允许出现抽象方法和常量(psf)

               1.8开始,可以出现静态方法和默认方法(等同看成成员方法)

        接口中,没有变量,只有常量(可以有局部变量),并且psf可以省略,接口中,权限控制默认是公共的

        并且抽象方法的abstract 可以省略

        接口不能创建对象,没有构造方法,但是能发生多态   父接口  变量 = new 子类();

        类和接口之间,不再是继承关系(extends) , 而是 实现关系(implements),并且是多实现,多个用逗号隔开

                一个普通类实现接口,需要实现(覆写)所有的抽象方法

                一个抽象类实现接口,需要实现0~N个抽象方法

        接口和接口直接,是继承关系(extends),并且是多继承,多个用逗号隔开

        如果接口和抽象类都能实现某个功能的时候,优先使用接口

        因为类和接口直接是多实现的关系,如果使用接口这样会保留类继承,扩展性更强

        2.2 使用方法

interface A{
        //公共的常量
        int age = 2;
        public static final int aa = 1;
        //公共的抽象方法
        void m1();
        public void m2();
        public abstract void m3();
        //静态方法
        public static void m4(){
                System.Out.println("静态方法")；
        }
        //默认方法就是成员方法，需要创建子类对象进行调用
        default void m5{
        System.out;println("默认方法"）;
        }
        }
        interface B{}
        interface C extends A,B{}
        // 继承和实现可以同时出现,也可以不同时出现        
        // 如果同时出现,则需要先写继承,后写实现
        class Sub_1 extends Object implements A,B,C{
                @Override
                public void m1() {
                }
                public void m2() {
                }
                @Override
                public void m3() {
                }
        }

3.Object

        3.1 概述

        Object 是java提供的根类(祖宗),所有类都直接或间接继承Object

        java.lang.Object; 在java.lang包下 , 这个包 是 核心包,用该包下所有的类,都不需要进行导入

        3.2 Equals 

        equals方法的设计目的 : 比较两个对象是否相等,但是 默认的equals比较的是内存地址

        == : 比较基本类型是比较的值的大小, 比如引用类型,比较的是内存地址

        如果我们不要比较内存地址,而且比较某些属性值的话,需要我们根据需求进行覆写

        String ,已经覆写了equals方法,比较的是值       

//应用

        class User {
                @Override
                public boolean equals(Object obj) {
                // 判断是不是同一个对象
                if (this == obj) {
                        return true;
                }
                // 判断是否是相同类型,不同类 没有可比性
                if (obj instanceof User) {
                        User u2 = (User) obj;
                        if (this.no == u2.no && this.name.equals(u2.name)) {
                                return true;
                                }
                        }
                        return false;
                   }

        3.3 Finalize

        JVM : 跨平台,多线程,面向对象,自动垃圾回收

        面向对象 : 封装,继承,抽象,多态

        垃圾 : 没有任何引用指向该对象的时候,则该对象为垃圾数据

        就是堆内存有个对象,但是谁也找不到它

        垃圾在被回收的时候,会自动调用该对象的finalize方法,是在对象生命周期要结束的时候,被调用的

        所以 适合做一些关闭资源等操作

        finalize是没有回收功能的,只是要被回收之前,自动被调用而已,我们也可以手动调用finalize方法,但是仅仅是方法调用而已

        3.4 toString

        toString : 该方法代表了该对象的字符串形式的描述方式

        输出一个引用类型的时候,会自动调用该对象的toString方法 , 默认的toString方法是打印内存地址

        如果打印不要内存地址,或者需要以特定格式打印输出,则需要我们自己覆写该方法