java学习day012

一.抽象

1.1 概述

        抽象:往往用来表示设计中得出的抽象概念,一般不会有具体的实体表示 ​ 比如动物,他只是一个抽象的概念,并没有一个具体的东西叫动物 ​ 所以动物就不能代表一个具体的实体,就意味着,动物类,是不能创建对象的 ​ 所以此时动物类,应该定义为抽象类

1.2 怎么用

使用abstract修饰符对类或者方法进行抽象

//动物类
abstract class Animal {
    //动物吃东西的功能
    public abstract void eat();
    public void m1(){
}
//猫
class Cat extends Animal {
    Cat(){
        super();
    }
    @Override
    public void eat() {
        System.outprintln("猫吃鱼");
    }
}

1.3 注意

1.修饰类为抽象类,并且抽象类不能创建对象,但是依然有构造方法,用于子类创建对象时调用(super()); ​
2.修饰的方法为抽象方法,抽象方法没有{方法体},用于被子类实现.(本质上是在子类中对父类进行方法覆写) ​
3.抽象方法,必须在抽象类,而抽象类中不一定有抽象方法 ​
4.final 和 abstract 不能同时修饰 ​ 因为final表示最终,不可修改,修饰的类不能被继承,修饰的成员方法不能被覆写 ​ 而abstract表示抽象的,抽象类和抽象方法,就是用于被继承.被子类实现覆写的 ​
5.普通类有的抽象类都有而且抽象类中还用于抽象方法

二.接口

2.1 概述

面向接口编程

接口是解决java中单继承导致功能变弱问题 ​ 一个类只能继承一个类,但是可以实现多个接口 ​ 使用接口,也是可以发生多态的

2.2 优点

和多态的优点一样,降低耦合度

2.3 怎么用

接口中没有变量,只有常量 public Static final,并且 psf可以省略 ​
 由此定义类的关键字由class变为interface ​
 1.8之前,接口中没有其他方法,只有抽象方法和常量 ​
 1.8以后,接口中可以重新default方法(类似成员方法,用来给子类使用)和静态方法

interface A{
    //常量
    public static final int a = 2;
    //psf可以省略
    int b = 3;
    //抽象方法
    public abstract void m1();
    //public abstract 可以省略
    void m2();
    // 通过 接口名.静态方法()调用
    public static void m3(){
        System.out.println("静态方法");
    }
    // 可以等同看做成员方法
    // 通过子实现类对象调用
    default void m4(){
        System.out.println("默认方法");
    }
}
​
interface B(){    
}
​
interface C extends A,B{
}
​
//一个类实现接口后,需要实现所有的抽象方法
class D extends Object implements A,B{
    D(){
        super();
    }
    @Override
    public void m1(){        
    }
    
    @Override
    public void m2(){        
    }
    
}
​
//一个抽象类实现接口后,可以实现0~n个方法
abstract class E implements A,B{
    
}
​
public static void main(String[] args){
    //子实现类对象
    D d = new D();
    //默认方法
    d.m4();
    //接口静态方法
    A.m3();
    //接口中常量
    System.out.println(A,a)
}

2.4 注意

接口可以看做是特殊的抽象类.完全抽象

接口不能创建对象,没有构造方法,(注意抽象类可以创建构造方法)

一个类实现接口后需要实现所有的抽象方法(方法可以为空但不能没有)

一个抽象类实现接口后,可以实现0~n个方法(抽象类内可以不覆写接口内的方法)

类和类 单继承 extends 类和接口 多实现 implements(多个逗号隔开) 接口和接口之间 多继承(多个逗号隔开) 继承和实现可以同时存在,先继承,后存在

2.5 接口和抽象类的区别

       如果某个功能通过抽象类和接口都能完成,优先使用接口 ​
        1.因为类和类是单继承,而类和接口是多实现 ​
        2.我们使用接口的话,会保留类继承,扩展性更强

三.object

java提供的根类,所有类都直接或者间接继承Object

3.1 toString

返回这个对象的字符串表现形式,当输出一个引用类型的时候,会自动调用该方法的toString方法 ​ 默认的toString方法是打印 : 包名.类名@十六进制值

interface A{
    //常量
    public static final int a = 2;
    //psf可以省略
    int b = 3;
    //抽象方法
    public abstract void m1();
    //public abstract 可以省略
    void m2();
    // 通过 接口名.静态方法()调用
    public static void m3(){
        System.out.println("静态方法");
    }
    // 可以等同看做成员方法
    // 通过子实现类对象调用
    default void m4(){
        System.out.println("默认方法");
    }
}
​
interface B(){    
}
​
interface C extends A,B{
}
​
//一个类实现接口后,需要实现所有的抽象方法
class D extends Object implements A,B{
    D(){
        super();
    }
    @Override
    public void m1(){        
    }
    
    @Override
    public void m2(){        
    }
    
}
​
//一个抽象类实现接口后,可以实现0~n个方法
abstract class E implements A,B{
    
}
​
public static void main(String[] args){
    //子实现类对象
    D d = new D();
    //默认方法
    d.m4();
    //接口静态方法
    A.m3();
    //接口中常量
    System.out.println(A,a)
}

3.2 Equals

equals用于比较两个对象是否相同,默认比较内存地址(需要根据需求重写)(String类型已经覆写了equals方法,比较的是值)

"==" : 比较基本类型的时候,比较的是值的大小,而比较引用类型的时候,只能比较内存地址是否相同

String比较要用equals

class Student{
    private int id;
    private String name;
    public Student(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
//需求:lD和name都相同,就认为相同
    @Override
    public boolean equals(Object obj){
    //1 先比较是不是同一个对象
    if (this == obj){
        return true;
    }
    //2判断是否同类,不同类不具备可比性
    if (obj instanceof Student) {
        //向下转型,多态丢失子类特有属性Student s = (Student) obj;
        if (this.id == s.id && this.name.equals(s.name)) {
            return true;
        }
    }
return false;

3.3 Finalize

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

finalze方法,是当垃圾被回收之前,jvm会自动调用该对象的finalize方法,由于finalize方法是回收的时候执行,并且只执行一次,所以适合做关闭资源等收尾工作 finalize方法是jvm自动调用,该方法并没有回收垃圾的功能,如果我们手动调用,也只是单纯的方法调用而已

public class Finalize_01 {
public static void main(String[] args){
    //创建一个垃圾
    for (int i = 0; i < 10000000; i++){
        new User();
    }
    //程序员可以建议JVM回收垃圾
    // System.gc();
    }
}
​
class User {
    @Override
    public void finalize(){
        System.outprintln(this +"我要被回收了");}
    }
}
​