Java学习中的extends

A

package com.mashibing.extend;

/**
 * @author: 马士兵教育
 * @create: 2019-08-25 15:25
 */
public class A {

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

    @Override
    public int hashCode() {
        return super.hashCode();
    }
}

B

package com.mashibing.extend;

/**
 * @author: 马士兵教育
 * @create: 2019-08-25 15:25
 */
public class B {

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

C

package com.mashibing.extend;

/**
 * @author: 马士兵教育
 * @create: 2019-08-25 15:25
 */
public class C extends A {

    public static void main(String[] args) {
        C c = new C();
        c.test();
//        Test2 test2 = new Test2();
    }
}

Pet

package com.mashibing.extend;

/**
 * @author: 马士兵教育
 * @create: 2019-08-25 15:13
 */
public class Pet {

    private String name;
    private int age;
    private String gender;
    protected String abc;

    public Pet(){
        System.out.println("pet 无参构造方法");
    }

    public Pet(String name, int age, String gender) {
//        this();
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    private void play(){
        System.out.println("play.....");
    }

    public static void test(){
        System.out.println("static test");
    }
    @Override
    public String toString(){
        return "my name is "+this.name+",my age is "+this.age+",my gender is"+this.gender;
    }
}

Dog

package com.mashibing.extend;

/**
 * @author: 马士兵教育
 * @create: 2019-08-25 15:10
 */
public class Dog extends Pet{

//    private String name;
//    private int age;
//    private String gender;
    private String sound;

    public Dog(){
        System.out.println("dog 无参构造");
    }

    public Dog(String name, int age, String gender, String sound) {
//        super(name,age,gender);
        this.sound = sound;
    }

//    public String getName() {
//        return name;
//    }
//
//    public void setName(String name) {
//        this.name = name;
//    }
//
//    public int getAge() {
//        return age;
//    }
//
//    public void setAge(int age) {
//        this.age = age;
//    }
//
//    public String getGender() {
//        return gender;
//    }
//
//    public void setGender(String gender) {
//        this.gender = gender;
//    }

    public String getSound() {
        return sound;
    }

    public void setSound(String sound) {
        this.sound = sound;
    }

    public void play(){
        System.out.println("dog is playing ball");
//        super.play();
    }


    public String toString(){
        return super.toString()+",my sound is"+this.sound;
    }
}

Penguin

package com.mashibing.extend;

/**
 * @author: 马士兵教育
 * @create: 2019-08-25 15:12
 */
public class Penguin extends Pet{

//    private String name;
//    private int age;
//    private String gender;
    private String color;

    public Penguin(){

    }

    public Penguin(String name, int age, String gender, String color) {
//        this.name = name;
//        this.age = age;
//        this.gender = gender;
        super(name,age,gender);
        this.color = color;
    }

//    public String getName() {
//        return name;
//    }
//
//    public void setName(String name) {
//        this.name = name;
//    }
//
//    public int getAge() {
//        return age;
//    }
//
//    public void setAge(int age) {
//        this.age = age;
//    }
//
//    public String getGender() {
//        return gender;
//    }
//
//    public void setGender(String gender) {
//        this.gender = gender;
//    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void play(){
        System.out.println("penguin is playing ice");
    }
}

PetTest

/*

• 继承：
• 表示父类跟子类之间的关系
• 当两个类或者多个类具备相同的属性和方法的时候，可以提取出来，变成父类，子类可以继承
• 子类跟父类是is-a的关系
• 使用：

•   1、使用继承的时候需要使用extend关键字
  

•   2、使用继承关系之后，父类中的属性和方法都可以在子类中进行使用(非私有属性和非私有方法)
  

•   3、java中是单继承关系(如果包含多个父类，同时父类中包含重名方法，无法决定改调用谁)
  

• super:是 直接父类 对象的引用
• 用途：

•   1、可以在子类中调用父类中被子类覆盖的方法  super.父类方法名称
  

•   2、当super在普通方法中使用的话，可以任意位置编写
  

•   3、当super在构造方法中使用的话，会调用父类的构造方法，一定要将super放在第一行
  

•   4、在构造方法中super关键字和this关键字不能同时出现
  

•   5、父类中私有的属性和方法都不能被调用，包括构造方法
  

•   6、子类的构造方法中都会默认使用super关键字调用父类的无参构造方法,因此在定义类的时候，无论自己是否自定义了
  

•           其他构造方法，最好将无参构造方法写上
  

•   7、如果构造方法中显式的指定了super的构造方法，那么无参的构造方法就不会被调用
  

• 总结：

•   1、在创建子类对象的时候一定会优先创建父类对象
  

•   2、所有的java类都具备同一个老祖宗类，称之为Object，是所有类的根类
  

• 重写：
• 必须要存在继承关系，当父类中的方法无法满足子类需求的时候可以选择使用重写的方式
• 注意：

•   1、重写表示的是子类覆盖父类的方法，当覆盖之后，调用同样的方法的时候会优先调用子类
  

•   2、重写的方法名称，返回值类型，参数列表必须跟父类一直
  

•   3、子类重写的方法不允许比父类的方法具备更小的访问权限
  

•       父类      public     子类  public
  

•       父类      protected     子类  public protected
  

•       父类      protected     子类  public protected  default
  

• 父类的静态方法子类可以进行调用，但是子类不可以重写
• */

package com.mashibing.extend;

/**
 * @author: 马士兵教育
 * @create: 2019-08-25 15:14
 */

/*
* 继承：
*   表示父类跟子类之间的关系
*   当两个类或者多个类具备相同的属性和方法的时候，可以提取出来，变成父类，子类可以继承
*
*   子类跟父类是is-a的关系
*
*   使用：
*       1、使用继承的时候需要使用extend关键字
*       2、使用继承关系之后，父类中的属性和方法都可以在子类中进行使用(非私有属性和非私有方法)
*       3、java中是单继承关系(如果包含多个父类，同时父类中包含重名方法，无法决定改调用谁)
*
*
* super:是 直接父类 对象的引用
*   用途：
*       1、可以在子类中调用父类中被子类覆盖的方法  super.父类方法名称
*       2、当super在普通方法中使用的话，可以任意位置编写
*       3、当super在构造方法中使用的话，会调用父类的构造方法，一定要将super放在第一行
*       4、在构造方法中super关键字和this关键字不能同时出现
*       5、父类中私有的属性和方法都不能被调用，包括构造方法
*       6、子类的构造方法中都会默认使用super关键字调用父类的无参构造方法,因此在定义类的时候，无论自己是否自定义了
*               其他构造方法，最好将无参构造方法写上
*       7、如果构造方法中显式的指定了super的构造方法，那么无参的构造方法就不会被调用
*
*   总结：
*       1、在创建子类对象的时候一定会优先创建父类对象
*       2、所有的java类都具备同一个老祖宗类，称之为Object，是所有类的根类
*
* 重写：
*   必须要存在继承关系，当父类中的方法无法满足子类需求的时候可以选择使用重写的方式
*   注意：
*       1、重写表示的是子类覆盖父类的方法，当覆盖之后，调用同样的方法的时候会优先调用子类
*       2、重写的方法名称，返回值类型，参数列表必须跟父类一直
*       3、子类重写的方法不允许比父类的方法具备更小的访问权限
*           父类      public     子类  public
*           父类      protected     子类  public protected
*           父类      protected     子类  public protected  default
*   父类的静态方法子类可以进行调用，但是子类不可以重写
* */
public class PetTest {

    public static void main(String[] args) {

//        Dog dog = new Dog("小黑",12,"男","汪汪");
//        dog.setName("大黄");
//        System.out.println(dog.getName());
//        dog.play();
//        dog.p

        Pet pet = new Pet();
        System.out.println(pet);
        Dog dog = new Dog();
        System.out.println(dog);
        dog.test();
    }
}

Student

package com.mashibing.extend;

import java.util.Objects;

/**
 * @author: 马士兵教育
 * @create: 2019-08-31 15:22
 */
public class Student {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }

    public static void main(String[] args) {
        Student s1 = new Student("zhangsan",12);
        Student s2 = new Student("zhangsan",12);
        System.out.println(s1==s2);
        System.out.println(s1.equals(s2));
    }
}