小白学Java第七课重写与继承

Java继承的实现，继承让我们更加容易实现类的扩展，可以实现代码的重用，但是继承并不能得到父类的构造方法，可以获得除了构造方法以外的所有属性和方法，不过不一定可以直接访问如父类的私有属性和方法。
并且Java中没有多继承，如果定义一个类时没有调用extends则它的父类是object类。
instanceof是二元运算符左边是对象右边是类当右面类或者子类所创建对象时，返回true；否则返回false。
相关代码：

public class TestExtends {
    public static void main(String[] args) {
        Student stu=new Student();
        stu.name="张三";
        stu.height=186;
        stu.study();
        Student stu1=new Student("李四",145,"计算机");
        System.out.println(stu1.name+stu1.ma+stu1.height);
        System.out.println(stu instanceof Person);//用于判断属于什么类型
    }
}
class Person/*extends object*/{
    String name;
    int height;
    public void play(){
        System.out.println("玩一会吧");
    }
}
class Student extends Person {
    String ma;

    public void study() {
        System.out.println("学习学习！");
    }

    public Student(String name,int height,String ma) {
    this.name=name;
    this.height=height;
    this.ma=ma;
    }
    public Student(){

    }
}

方法的重写：子类通过重写父类的方法，可以用自身的行为替换父类的行为，就是说一个父类的A方法已经有了，但是子类用的时候，这个方法不符合子类使用的要求，我想把里面的属性改一下，有自己独特的方法，这个时候就需要重写。
要点：
1、方法名、形参列表相同
2、返回值类型和声明异常类型，子类小于等于父类
3、访问权限、子类大于等于父类
相关代码：

public class Test {
    public static void main(String[] args) {
        Cat c=new Cat();
        c.run();
    }
}
class Animal{
    public void run(){
        System.out.println("跑啊");
    }
    public void stop(){
        System.out.println("stop");
    }
    public Person who(){
        return new Person();
    }
}
class Cat extends Animal{
    public void run(){
        System.out.println("跑");
    }
    public Person who(){//如果person换成object则不符合返回值类型小于等于父类
        return new Person();
    }
}

Object类是所有Java类的根基类，也就意味着所有的Java对象都用有着Object类的属性和方法。
测试代码：

public class Test1 {
    public static void main(String[] args) {
        //Object obj;
        Test1 to=new Test1();
        System.out.println(to.toString());//调用toString方法
        Person1 p1=new Person1("张三",123);
        System.out.println(p1);

    }
    public String toString(){//重写toString方法
        return "测试一下";
    }
}
class Person1{
    String name;
    int id;
    public String toString(){
        return name+"ID："+id;
    }
    public Person1(String name,int id){
        this.name=name;
        this.id=id;
    }
}

equals方法和==：
“==”代表比较双方是否相同，如果是基本类型表示值相等，如果是引用类型则表示地址相等即是同一个对象。
equals实际上是object类中提供的一个方法，提供定义“对象内容相等”的逻辑。默认看地址是否相同，是不是同一个对象。我们也可以根据我们的要求重写equals方法。
相关代码:

import java.util.Objects;

public class Test2 {
    public static void main(String[] args) {
        Object obj;
        String atr;
        Student1 stu1=new Student1(123,"jam");
        Student1 stu2=new Student1(123,"tom");
        System.out.println(stu1==stu2);
        System.out.println(stu1.equals(stu2));//未重写前输出为false

    }
}
class Student1{
    int id;
    String name;

    public Student1(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student1 student1 = (Student1) o;
        return id == student1.id;
    }//重写equals，只依赖ID来判断，
}

super关键字：
super是直接父类对象的引用。可以通过super来访问父类中被子类覆盖的方法或属性。
构造函数中第一行代码总是super（）…

相关代码：

public class Test3 {
    public static void main(String[] args) {
        new Cclass().f();
    }
}
class Fclass{
    public int v;
    public void f(){
        v=100;
        System.out.println(v);
    }
}
class Cclass extends Fclass{
    public  int v;
    public void f(){
        super.f();//调用父类对象的普通方法
        v=200;
        System.out.println("Cclass.v="+v);
        System.out.println(v);
        System.out.println(super.v);//父类的v
    }
}