• 面向对象三大特征之一：继承

             类可以有两种重要的成员:成员变量和方法。子类的成员中有一部分是子类自己声明、定义的，另一部分是从它的父类继承的。那么，

            什么叫继承呢?所谓子类继承父类的成员变量作为自己的一个成员变量，就好像它们是在子类中直接声明一样，可以被子类中自己定义的任何实例方法操作，也就是说，一个子类继承的成员应当是这个类的完全意义的成员，如果子类中定义的实例方法不能操作父类的某个成员变量，该成员变量就没有被子类继承;所谓子类继承父类的方法作为子类中的一个方法，就像它们是在子类中直接定义了一样，可以被子类中自己定义的任何实例方法调用。

     

    使用继承

            编写父类

                    [访问修饰符] class Pet {     //公共的属性和方法 }

            编写子类，继承父类

                    [访问修饰符] class Dog extends Pet {     //子类特有的属性和方法 }

    继承是Java中实现代码重用的重要手段之一。Java中只支持单根继承，即一个类只能有一个直接父类
     

    案例：

    1. package cn.bdqn.demo04;
    2.  
    3. public class Pet {
    4. 	private String name;
    5. 	private int health;
    6. 	private int love;
    7.  
    8. 	// 添加构造方法
    9. 	public Pet() {
    10. 	}
    11.  
    12. 	public Pet(String name, int health, int love) {
    13. 		this.name = name;
    14. 		this.health = health;
    15. 		this.love = love;
    16. 	}
    17.  
    18. 	public String getName() {
    19. 		return name;
    20. 	}
    21.  
    22. 	public void setName(String name) {
    23. 		this.name = name;
    24. 	}
    25.  
    26. 	public int getHealth() {
    27. 		return health;
    28. 	}
    29.  
    30. 	public void setHealth(int health) {
    31. 		this.health = health;
    32. 	}
    33.  
    34. 	public int getLove() {
    35. 		return love;
    36. 	}
    37.  
    38. 	public void setLove(int love) {
    39. 		this.love = love;
    40. 	}
    41.  
    42. 	public void print() {
    43. 		System.out.println("宠物信息：昵称：" + this.getName() + "，健康值："
    44. 				+ this.getHealth() + "，亲密度：" + this.getLove());
    45. 	}
    46.  
    47. }
    1. package cn.bdqn.demo04;
    2.  
    3. public class Cat extends Pet {
    4.  
    5. 	// 定义Cat类独有的属性
    6. 	private String color;
    7.  
    8. 	public Cat() {
    9. 		super();// 调用父类Pet类里的无参构造方法
    10. 	}
    11.  
    12. 	public Cat(String name, int health, int love, String color) {
    13. 		super(name, health, love);
    14. 		this.color = color;
    15. 	}
    16.  
    17. 	public String getColor() {
    18. 		return color;
    19. 	}
    20.  
    21. 	public void setColor(String color) {
    22. 		this.color = color;
    23. 	}
    24.  
    25. }
    1. package cn.bdqn.demo04;
    2.  
    3. public class Dog extends Pet {
    4. 	//strain属性是DOg类里独有的属性，其它类没有，所以要在Dog类里定义
    5. 	private String strain;
    6.  
    7. 	public Dog() {
    8. 	}
    9.  
    10. 	public Dog(String name, int health, int love, String strain) {
    11. 		super(name, health, love);
    12. 		this.strain = strain;
    13. 	}
    14.  
    15. 	public String getStrain() {
    16. 		return strain;
    17. 	}
    18.  
    19. 	public void setStrain(String strain) {
    20. 		this.strain = strain;
    21. 	}
    22. 	
    23. 	
    24. }
    1. package cn.bdqn.demo04;
    2.  
    3. public class Penguin extends Pet {
    4.  
    5. 	// 定义Penguin类里独有的属性
    6. 	private String sex;
    7.  
    8. 	public Penguin() {
    9. 		super();// super表示父类Pet对象，所以这个地方表示调用父类的无参构造方法
    10. 	}
    11.  
    12. 	public Penguin(String name, int health, int love, String sex) {
    13. 		super(name, health, love);// 表示调用父类Pet类的有参构造方法
    14. 		this.sex = sex;
    15. 	}
    16.  
    17. 	public String getSex() {
    18. 		return sex;
    19. 	}
    20.  
    21. 	public void setSex(String sex) {
    22. 		this.sex = sex;
    23. 	}
    24.  
    25. }
    1. package cn.bdqn.demo04;
    2.  
    3. public class Test {
    4.  
    5. 	public static void main(String[] args) {
    6. 		// 创建Dog类对象
    7. 		Dog dog1 = new Dog("旺财", 99, 99, "金毛");
    8. 		//在Dog类中没有setName()方法，但是DOg类对象dog1是可以调用，因为Dog类继承了Pet类，所以dog1可以调用父类Pet类里的setName()方法
    9. 		dog1.setName("来福");
    10. 		dog1.print();
    11. 		
    12. 		//创建Penguin类对象
    13. 		Penguin penguin1 = new Penguin("QQ", 98, 100, "公");
    14. 		penguin1.setHealth(100);
    15. 		penguin1.print();
    16. 		
    17. 		//创建Cat类对象
    18. 		Cat cat1 = new Cat("Tom", 100, 80, "蓝色");
    19. 		cat1.print();
    20. 		
    21. 		//hashCode()在Cat里没有、在Cat的父类Pet类里也没有，hashCode()方法存在于Object类中，Object类是Pet类的默认父类，所以Cat类对象可以使用Pet类里的方法，也可以使用Pet类的父类里的方法
    22. 		//声明一个类，如果没有指定其父类是谁，系统会让此类默认去继承Object类
    23. 		
    24. 		
    25. 		int num =cat1.hashCode();
    26. 		System.out.println(num);//1694203642
    27.  
    28. 	}
    29.  
    30. }

     

    super

    子类访问父类成员

            访问父类构造方法

                    super();     super(name);

            访问父类属性

                    super.name;

            访问父类方法

                    super.print();

    super关键字： 

      (1）使用super关键字,super代表父类对象

    （2）在子类构造方法中调用且必须是第一句

    （3）不可以访问父类中定义为private的属性和方法

    super关键字来访问父类的成员

            super只能出现在子类的方法和构造方法中

            super调用构造方法时，只能是第一句

            super不能访问父类的private成员

            继承条件下构造方法的调用规则

                    子类构造方法没有通过super显式调用父类的有参构造方法，也没通过this显式调用自身其他构造方法

                            系统默认调用父类的无参构造方法

                    子类构造方法通过super显式调用父类的有参构造方法

                            执行父类相应构造方法，而不执行父类无参构造方法

                    子类构造方法通过this显式调用自身的其他构造方法，在相应构造方法中应用以上两条规则

    子类继承父类的什么？

            继承public和protected修饰的属性和方法，不管子类和父类是否在同一个包里

            继承默认权限修饰符修饰的属性和方法，但子类和父类必须在同一个包里

    案例：

    1. package cn.bdqn.demo05;
    2.  
    3. public class Father {
    4. 	
    5. 	private String name;
    6. 	private int age;
    7. 	public double height;
    8. 	
    9. 	public Father() {
    10. 		super();//调用Father类的父类Object类的无参构造方法
    11. 		System.out.println("我是Father类里的无参构造方法");
    12. 	}
    13.  
    14. 	public Father(String name, int age,double height) {
    15. 		super();//调用Father类的父类Object类的无参构造方法
    16. 		this.name = name;
    17. 		this.age = age;
    18. 		this.height = height;
    19. 		System.out.println("我是Father类里的有参构造方法");
    20. 	}
    21.  
    22. 	public String getName() {
    23. 		return name;
    24. 	}
    25.  
    26. 	public void setName(String name) {
    27. 		this.name = name;
    28. 	}
    29.  
    30. 	public int getAge() {
    31. 		return age;
    32. 	}
    33.  
    34. 	public void setAge(int age) {
    35. 		this.age = age;
    36. 	}
    37. 	
    38. 	
    39. 	private void test(){
    40. 		System.out.println("我是Father类里的私有test()方法");
    41. 	}
    42. 	
    43. 	public void print(){
    44. 		System.out.println("我是Father类里的公共print()方法");
    45. 	}
    46.  
    47. }

    1. package cn.bdqn.demo05;
    2.  
    3. public class Son extends Father {
    4. 	private double money;
    5.  
    6. 	public Son() {
    7. 		super();//调用的Son类的父类Father类里的无参构造方法
    8. 		System.out.println("我是Son类里的无参构造方法");
    9. 	}
    10.  
    11. 	public Son(String name, int age, double height, double money) {
    12. 		super(name, age, height);//调用Son类的父类Father类里的有参构造方法
    13. 		this.money = money;
    14. 		System.out.println("我是Son类里的有参构造方法");
    15. 	}
    16.  
    17. 	public double getMoney() {
    18. 		return money;
    19. 	}
    20.  
    21. 	public void setMoney(double money) {
    22. 		this.money = money;
    23. 	}
    24. 	
    25.  
    26. 	public void printInfo(){
    27. 		//输出父类里的属性
    28. 		//super不能直接调用父类里被private修饰的属性
    29. //		System.out.println(super.name);
    30. //		System.out.println(super.age);
    31. 		System.out.println(super.height);
    32. 		
    33. 		//super不能直接调用父类里被private修饰的方法
    34. //		super.test();
    35. 		super.print();
    36. 	}
    37.  
    38. }

    1. package cn.bdqn.demo05;
    2.  
    3. public class Test {
    4.  
    5. 	public static void main(String[] args) {
    6. 		// 使用Son类的无参构造方法创建对象
    7. 		Son son1 = new Son();
    8. 		//创建Son类对象一共调用了几次构造方法？？？ 3次
    9. 		
    10. 		System.out.println("----------------");
    11. 		
    12. 		Son son2 = new Son("张三", 22, 173, 999);
    13. 		son2.printInfo();
    14.  
    15. 	}
    16.  
    17. }

     不能被继承的父类成员

            private成员

            子类与父类不在同包， 使用默认访问权限的成员

            构造方法

    何时使用继承？

    继承与真实世界类似

            只要说“猫是哺乳动物”，猫的很多属性、行为就 不言自明了

            藏獒是一种狗

    符合is-a关系的设计使用继承

    继承是代码重用的一种方式

    将子类共有的属性和行为放到父类中

  • 相关阅读:
    WPF 控件专题 ListView 样式（斑马线）
    （76）MIPI DSI LLP介绍（十六）
    linux 查看内存大小
    【Python脚本进阶】1.1、基础环境
    飞行员需要新的策略来解决资金被困、外汇危机
    51单片机烟雾报警器mq2烟雾报警ADC0832采集实践制作DIY- GC0026-烟雾报警器
    我们在SqlSugar开发框架中，用到的一些设计模式
    使用并查集实现查找无向图的连通分量和求解有向图的强连通分量
    docker 配置mongoDB
    Spring boot 启动流程及外部化配置
  • 原文地址：https://blog.csdn.net/qq_51810428/article/details/126148611