多态-一个行为多种状态。比如打篮球 打羽毛球 同样是打 但是动作规则完全不一样。

java里面的多态也是类似。

• 子类继承父类
• 父类引用指向子类对象
• 子类重写了父类方法

当使用父类引用调用被重写的方法时，实际执行的是子类的方法，这就是多态。

class Father {
    void say() {
        System.out.println("Father say");
    }
}

class Son extends Father {
    @Override
    void say() {
        System.out.println("Son say");
    }
}

class Daughter extends Father {
    @Override
    void say() {
        System.out.println("Daughter say");
    }
}

public class Test {
    public static void main(String[] args) {
        Father f1 = new Son();
        Father f2 = new Daughter();
        f1.say(); // 输出 Son say
        f2.say(); // 输出 Daughter say
    }
}

抽象类

把方法的实现部分去掉，直接以分号结束，增加abstract修饰符，就构成了抽象方法。

public abstract void talk();

抽象方法就是为了重写的。就是我自己不实现，交给子类去实现。

当一个类含有抽象方法的时候，则该类必须声明为抽象类。抽象类不能被实例化，需增加abstract修饰符。

抽象方法只需要声明，而不需要实现。

abstract class Animal {
    public abstract void talk();

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

class Dog extends Animal {
    @Override
    public void talk() {
        System.out.println("汪汪");
    }
}

Final关键字

final的变量的值不能够被改变

class A{
    final int i = 9;
}

A a = new A();
// a.i = 3; // 编译出错

final的方法不能够被重写

class Father {
    final void method() {}
}

class Son extends Father {
    // void method() {} // 编译出错，不能重写final方法
}

final的类不能够被继承

final class Father {}

// class Son extends Father {} // 编译出错，不能继承final类

接口

接口是抽象方法和常量值的集合。

从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。

public interface IAnimal {
    public static final int id = 1;

    public void run();
    public void eat();
}

接口可以多重实现，也就是变相的多重继承。

接口成员变量只能是public static final，就算不写也是这个。

接口只能定义抽象方法，默认是public abstract，也只能是public abstract。

接口可以继承其他接口，并添加新的属性和抽象方法。

实现接口需要用implements。

interface IAnimal {
    int id = 1; // 默认 public static final
    void run(); // 默认 public abstract
    void eat();
}

class Dog implements IAnimal {
    @Override
    public void run() {
        System.out.println("dog run");
    }

    @Override
    public void eat() {
        System.out.println("dog eat");
    }
}

interface IHuman extends IAnimal {
    void speak();
}

Object类中定义了toString()方法，返回对象的字符串表示。默认返回的是类名@哈希码的十六进制形式。

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

当使用System.out.println(对象)时，会自动调用该对象的toString()方法。

实际开发中通常会重写toString()方法，返回更有意义的对象信息。

class Student {
    String name;
    int age;

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

hashcode方法

hashCode()方法返回对象的哈希码值，是一个int类型的值。

同一个对象在程序的一次执行期间，多次调用hashCode()应当返回相同的整数，前提是对象中用于equals比较的信息没有被修改。

如果根据equals()方法两个对象相等，那么对这两个对象分别调用hashCode()应当产生相同的整数结果。

如果重写了equals()方法，通常也需要重写hashCode()方法，以保持equals相等则hashCode相等的约定。

class Student {
    String name;
    int age;

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

equals方法

equals()方法用于判断两个对象是否相等。Object类中的默认实现是比较对象引用是否指向同一个内存地址。

public boolean equals(Object obj) {
    return (this == obj);
}

实际开发中通常需要重写equals()方法，根据对象的属性来判断逻辑上的相等性。

class Student {
    String name;
    int age;

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Student student = (Student) obj;
        return age == student.age && name.equals(student.name);
    }
}

对象转型

一个基类的引用可以指向子类对象

Father f = new Son();

一个基类的引用不可以访问其子类对象新增的成员，包括属性和方法。

可以使用引用变量instanceof类名来判断该类型变量所指向的对象是否属于该类或者该类的子类

Son s = new Son();
boolean b = s instanceof Father; // true

子类对象可以当作基类的对象来使用称为向上转型，反之称为向下转型。

Father f = new Son(); // 向上转型，自动完成
Son s2 = (Son) f;     // 向下转型，需要强制类型转换

向下转型前通常需要先用instanceof判断，否则可能出现ClassCastException。

Father f = new Son();
if (f instanceof Son) {
    Son s = (Son) f;
}

如果在类的声明中未使用extends关键字，则其基类默认是Object类。

public class Student{

}

等价于

public class Student extends Object {

}

Object类提供了一些常用方法，比如toString()、equals()等，这些方法可以被子类继承或重写。

class Student {
    String name;
    int age;

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

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Student student = (Student) obj;
        return age == student.age && name.equals(student.name);
    }
}

class Father {
    public int number = 10;
}

class Son extends Father {
    public int number = 20;

    void show() {
        System.out.println(number);       // 子类自己的number，输出20
        System.out.println(super.number); // 父类的number，输出10
    }
}

子类的构造函数中，需要调用父类的构造函数来完成父类部分的初始化。

可以使用super(参数)来显式调用父类的构造函数，也可以使用this(参数)来调用子类自身的其他构造函数。

注意：super()调用父类构造函数时，必须放在子类构造函数体的第一行。

另外，如果子类的构造函数中没有显式调用父类的构造函数，则系统会默认调用基类的无参构造函数。

如果子类的构造函数没有显式调用父类的构造函数，而基类中又没有定义无参构造函数（比如基类只定义了带参构造函数），则编译会出错。

class Father {
    public int number;

    Father(int n) {
        number = n;
    }
}

class Son extends Father {
    Son() {
        // 编译出错：没有显式调用父类构造函数，且父类没有无参构造函数
        // 必须显式调用 super(参数)
    }

    Son(int n) {
        super(n); // 正确：显式调用父类带参构造函数
    }
}

重写方法必须和被重写方法具有相同方法名称，参数列表和返回类型。

重写方法不能使用比被重写方法更严格的访问权限。

一个person 类 有一个showinfo方法 显示姓名和年龄

一个student类 从person中继承

重写它的showinfo方法，显示姓名 年龄 还有学校名称。

class Person {
    String name;
    int age;

    void showInfo() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

class Student extends Person {
    String school;

    @Override
    void showInfo() {
        System.out.println("姓名：" + name + "，年龄：" + age + "，学校：" + school);
    }
}

修饰符	类内部	同一个包	子类	任何地方
private
default
protected
public

以上是成员变量和成员方法的访问修饰符。

对于class的权限修饰只有public和default：

• public类可以在任意地方被访问
• default类只可以被同一个包内部的类访问

不管是哪种，要访问一个类都需要import或者写全名。如果是default，则跨包后就无法访问。

通过继承，子类自动拥有了基类的所有成员。

java只支持单继承，不允许多继承。

一个子类只能有一个父类。 一个类可以被多个子类继承。

java里面使用extends 来实现继承。

class Son extends Father{

}

什么什么是一种什么东西。那么这个就是继承关系。

比如：学生是一个人，那么学生就继承人类。

狗是一个动物，那么狗就继承动物类。

在实际开发中，如果A是一个B，就可以使用继承来设计。

比如 java.lang

java.awt

java.net

java.io

java.util

我们也可以把我们的类打包到一个包。

jar -cvf  xxx.jar *.*

提供类的多重命名的问题。

比如 一班张三 和二班张三 。虽然都叫张三 但是由于在不同的班上面 所以 不会冲突。但是 如果他们都在同一个包里面 那么就会有问题了。

package 需要放在源代码的第一行。

package cn.foxdevelop;

如果缺省该语句则表示是无名包。

java编译器会把包对应到文件系统的目录管理中，比如 cn.foxdevelop 那么就会创建一个cn目录 然后再创建一个foxdevelop的子目录。里面放我们的这个.java文件。

如果我们要在其他类中调用这个类 则需要使用import引入这个类 要不然 没法使用这个类。

比如 现在在A.java 中引入

import cn.foxdevelop.B;

如果在这个包下面有多个类 比如还有C 如果想使用整个包 则可以使用*号

import cn.foxdevelop.*;

如果不引入 也可以 我们需要把它的名称写全。

比如

cn.foxdevelop.B b = new cn.foxdevelop.B();

用static声明的方法为静态方法，在调用该方法时，不会将对象的引用传递给它，所以static方法中不可以访问非static的成员。

（静态方法不再是针对某个对象调用，所以不能访问非静态成员）

可以通过对象引用或者类名（不需要实例化）访问静态成员。

静态成员 只有一份，不管new多少。它是在数据空间中 data segment

静态方法不能访问 非静态的成员 非静态的成员 必须通过对象 也就是需要先new了 才可以用

由于main方法是静态的 所以它不能直接访问 其他的成员 包括数据和方法。