Java类和对象（五）—— 抽象类、接口、Object类和内部类

抽象类

在继承体系下，父类有些方法可能是要被重写的，如果我们事先就知道某些方法需要重写的话，我们可以不用在父类里面具体实现这个方法，这时候我们会用到抽象方法，这时候我们会用到关键字abstract关键字来修饰

java 复制代码

public abstract class Animal {
    protected abstract void eat();
}

例如上面的Animal 类，每一个动物都会吃，但是每一个动物却吃的食物不同，父类的eat方法无法完全描述某个对象，这时候子类就需要重写这个方法，如果我们不想在父类具体实现这个eat方法的话，我们可以写成抽象方法~~

说完抽象方法，我们来类比一下抽象类：

如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类

抽象类也是用abstract 修饰的~~

注意要点

有抽象方法的类，一定是抽象类，所以如果方法被abstract修饰，那类也必须由abstract修饰，否则编译报错
抽象类是不能进行实例化的 ，但是可以有 继承的向上转型和向下转型~~
被private、static、final 修饰的方法不能是抽象方法

因为抽象方法就是为了被子类重写的，根据重写的规则，被private、static、final修饰的方法确实不能被重写
抽象类被继承后，继承后子类要重写父类中的抽象方法 ，除非子类也是抽象类 ，必须要使用 abstract 修饰，无论是谁继承了抽象类都必须重写所有的抽象方法，否则编译报错~~

当Dog继承Animal，必须重写Aniaml所有的抽象方法~~

如果Dog还是抽象类，Cat 继承 Dog，并且在 Cat 不是抽象的情况下，我们要在 Cat 这个类重写所有的抽象方法（即包括 Animal 也包括 Dog 的抽象方法）

抽象类的作用

抽象类就是用来被继承的

谁继承了抽象类，都必须重写抽象方法，否则编译报错，这也是为了多加一层编译器的校验

接口

接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。

在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型
我们使用 intarface 来定义接口，就是把class替换成interface

java 复制代码

public interface Ieat {
    void eat();
}

接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class

接口的使用规则

接口的成员方法是默认都是public static final 修饰的
接口的成员方法默认都是 public abstract 修饰的
当你在接口里定义了一个成员变量的时候，你必须对其进行初始化 ！！！

如果你想具体实现某些方法 ，你可以使用 static 或者 default 来进行修饰：

java 复制代码

public interface Ieat {
    static void eat(){
        //...
    }
    
    default void eat2(){
        //...
    }
}

访问权限也是和之前讲的是一样的，被static就是默认权限的静态方法，被default 修饰就是默认访问权限。

接口不能有实例化代码块、静态代码块，也不能有构造方法~~

如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类，如果被继承就必须重写所有的抽象方法！！！

这个和抽象类是类似的~~

软性规则：

创建接口时, 接口的命名一般以大写字母 I 开头 .

接口的命名一般使用 "形容词" 词性的单词.

阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性.

接口的继承

接口与接口之间可以多继承 。即：用接口可以达到多继承的目的。

接口可以继承一个或者多个接口, 达到复用的效果. 使用 extends 关键字。

java 复制代码

interface IA{
    void eat();
}

interface IB{
    void sleep();
}

interface C extends IA,IB{

}

接口的作用

解决了 Java 不能多继承的问题 ！！！

意味着一个类可以有多个接口！！！
如果子类由继承父类还有多个接口的时候，我们要先继承后接口（先extends 再 implements）

快捷键（搭建接口当中的抽象方法）

IDEA 中使用 ctrl + i 快速搭建接口当中的抽象方法~~
或者使用 alt + enter 进行选择implements methods 进行快速搭建接口，你选择Make 'Dog' abstract 的话就是讲这个类变为抽象类~~

接口的好处

java 复制代码

public class Animal {
    protected String name;
    protected int age;
}

public interface Irun {
    void run();
}

public class Cat extends Animal implements Irun{
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public void run() {
        System.out.println(this.name + "正在跑步");
    }
}

public class Dog extends Animal implements Irun{
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public void run() {
        System.out.println(this.name + "正在跑步");
    }
}

public class Test {

    public static void walk(Irun irun){
        irun.run();
    }

    public static void main(String[] args) {
        walk(new Dog("旺财",11));
        walk(new Cat("小咪",10));
    }
}

接口也可以有动态绑定和多态 ~~

由于接口可以实现多态，所以程序员可以不关注类型，只要有这个接口的类，都能调用里面的接口方法，而不用去关心这是什么类。

Object 类

Object是Java默认提供的一个类。Java里面除了Object类，所有的类都是存在继承关系的。默认会继承Object父类。即所有类的对象都可以使用Object的引用。

我们这里先重点关注一下上面标出来的三个方法：toString，equals，hashCode，

toString（打印对象）

java 复制代码

class Person{
    public String name;
    public int age;

}

public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person);
    }
}

我们在数组里知道直接打印数组名的话会出现包含数组的地址的一串字符串~~

如果直接打印对象的话，也会出现和数组类似的情况，这是为什么？

Java所有的类都会继承Object类，在调用println的时候，我们来看看一共调用了哪些方法：

首先println 方法如下：

之后无论是走if 语句还是else 语句，都会调用toString方法

最后就会来到toString 方法，这里getClass.getName()就是类名，然后加@符号，最后调用hashCode找到地址。

但是如果我们重写了 toString 方法的话，根据前面的知识，优先调用子类的方法来打印对象内容。

java 复制代码

class Person{
    public String name;
    public int age;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

这样的话，我们就会优先调用子类自己的toString 方法

我们可以使用编译器自动生成toString方法：

和之前搭建getter、setter还有构造方法是一样的，只是这里选择的是toString()

java 复制代码

class A{
    public String name;
    public int age;

    @Override
    public String toString() {
        return "A{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

equals

在Java当中，如果使用 == 来进行比较时

如果比较的是基本数据类型的话，就是比较两个的数值相不相同

如果比较的是引用数据类型，就会比较他们的地址相不相同

来我们看一下源码：

还是一样的，直接调用equals方法，还是比较两个对象的地址，所以如果想比较两个对象的内容相不相同就必须重写equals方法~~

java 复制代码

    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

java 复制代码

class Person{
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }
}

public class Test {
    public static void main(String[] args) {
        Person person1 = new Person("张三",10);
        Person person2 = new Person("张三",10);

        System.out.println(person1.equals(person2));
    }
}

比较对象中内容是否相同的时候，一定要重写equals方法。

hashCode

源码：

native 说明这是本地方法，这个是有C/C++代码编写的，我们是看不到的

简单来说，hashCode方法可以找到对象的内存地址

java 复制代码

public class Test {
    public static void main(String[] args) {
        Person person1 = new Person("张三",10);
        Person person2 = new Person("张三",10);

        System.out.println(person1.hashCode());
        System.out.println(person2.hashCode());
    }
}

由于这是两个不同的对象，所以他们的内存地址是不一样的~~

但是如果我们认为当两个对象的内容是一样的，那地址就应该是一样的话，我们就需要重写hashCode 方法~~

java 复制代码

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

这样他们的地址就会是一样的显示~~

快捷键搭建

以上三个方法都能使用快捷键快速搭建：

内部类

内部类就是在类里面再定义一个类，这个类定义的位置和外部类的成员是相同的。

静态内部类

被static修饰的内部成员类称为静态内部类。

java 复制代码

class A{
    public int age;
    public static int price;

    public A(){
        System.out.println("A()......");
    }

    public void methodA1(){
        System.out.println("methodA1()......");
    }

    public static void methodA2(){
        System.out.println("methodA2()......");
    }

    static class B{

        public void methodB(){
            //age = 10;//err,静态内部类只能访问外部类的静态成员
            //A();//不要在静态内部类中调用外部类的构造方法，构造方法是没有静态的，所以构造方法一定不是静态方法
            //methodA1(); //err,静态内部类只能访问外部类的静态成员,methodA1不是类方法（静态成员方法）
            price = 10;
            methodA2();
        }

    }

    //.....
}

注意事项

静态内部类只能访问外部类的静态成员

创建静态内部类

java 复制代码

A.B b = new A.B();

我们可以将静态内部类当成外部类的一个静态成员，静态成员的访问不需要创建对象，我们可以通过类名来访问，于是我们通过 A.B 就访问到了静态内部类，然后就通过new A.B 就可以完成创建了

实例内部类

未被static 修饰的实例内部类就是实例内部类
实例内部类可以自由访问外部类的任意成员 ，如果实例内部类和外部类有重名的成员 时，在内部类中优先访问自己的，如果真的相访问外部类同名的成员时 ，我们可以使用 外部类类名.this.成员 即可~~

java 复制代码

class A{
    public int age;
    public static int price;

    public A(){
        System.out.println("A()......");
    }

    public void methodA1(){
        System.out.println("methodA1()......");
    }

    public static void methodA2(){
        System.out.println("methodA2()......");
    }

    public void methodA3(){
        System.out.println("methodA3()......");
    }

    class C{

        public int age = 10;

        public void methodC(){
            System.out.println(age);
            methodA3();
            System.out.println(A.this.age);
            methodA1();
            A.this.methodA1();
        }

        public void methodA1(){
            System.out.println("C::methodA1()......");
        }
    }

    //.....
}

public class Test{
    public static void main(String[] args) {
        A.C c = new A().new C();
        c.methodC();
    }
}

创建实例内部类

我们要先创建外部类，再去创建实例内部类

java 复制代码

A.C c = new A().new C();

当然也可以分部去写：

java 复制代码

A a = new A();
A.C c = a.new C();

注意事项

1.外部类中的任何成员都可以在实例内部类方法中直接访问

2.实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束

3.在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名

称.this.同名成员来访问

4.实例内部类对象必须在先有外部类对象前提下才能创建

5.实例内部类的非静态方法中包含了一个指向外部类对象的引用

6.外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

匿名内部类

java 复制代码

class A{
    public void test1(){
        System.out.println("heihei");
    }
}

public class Test{

    public static void main(String[] args) {
        new A(){

        }.test1();
    }

}

通过后面的 .方法来调用相应的方法。

我们也可以重写匿名内部类的方法

但是要注意不能使用对象来接收匿名内部类

接口也可以使用：

java 复制代码

interface A{
    void test1();
}

public class Test{

    public static void main(String[] args) {
        new A(){
            public void test1(){
                System.out.println("haha");
            }
        };

    }

}

和上面不一样的是，接口是一定要重写其中的抽象方法的，并且花括号后面是不能直接 .方法的，而是要通过被接收后，然后去再去调用相应的方法~~

因此接口是可以被接收的，接收后也是可以继续使用的：

局部内部类

局部内部类是定义在方法里的，因此它的生命周期和方法是一样。

java 复制代码

    public void A() {
        //...
        
        class D{ 
            //......
        }
        
        //...
    }