java重点——面向对象--继承、super关键字

﹏ヽ暗。殇╰゛Y 2022-12-03 09:16 205阅读 0赞

# 1、继承 #

## 1.1、概述 ##

继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法。  
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

## 1.2、继承的特点 ##

●继承要有一定的层次结构，而且要具备一定的可传递性。

●子类继承了父类中所有的属性和方法，但是父类中的私有(private)属性和构造方法 除外。因为私有的属性只属于父类，作用范围也只能在父类中使用；父类的构造方 法是用来创建父类对象的，子类无法继承。

●子类除了可以拥有从父类中继承过来的属性和方法以外，子类也可以拥有自己的属 性和方法。

●Java 中只支持单一继承，也就是说一个子类只能有一个父类，但是一个父类可以拥 有多个子类。

## 1.3、继承的好处和弊端 ##

继承的好处：提高了代码的复用性(多个类相同的成员可以放到同一个类中) 提高了代码的维护 性(如果方法的代码需要修改，修改一处即可)

继承的弊端：继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也 不得不跟着变化，削 弱了子类的独立性

继承的应用场景：使用继承，需要考虑类与类之间是否存在 is…a 的关系，不能盲目使用继承 is…a 的 关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师 就是子类

## 1.4、继承的语法格式 ##

实现继承的格式  
继承通过 extends 实现  
格式：class 子类 extends 父类 \{ \}

举例：class Dog extends Animal \{ \}

继承带来的好处： 继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类 中非私有的成员。

通过 extends 关键字，来实现类和类之间的就继承关系，语法如下：

public class 父类{
         
     
    } //子类 
    class 子类 extends 父类{
         
     
    }

【父类也称为：基类、超类、根类】

package com.bdit; 
    /* 
    继承  
    */ 
    public class Test1 {
             
    	public static void main(String[] args) {
                 
    		S1 s1=new S1();         
    		s1.display();     
    	} 
    } 
    //定义父类 
    class F1{
             
    	private String name="土豪";     
    	private int age=88;     
    	double money=9999999999999.0;     
    	String house="10 栋别墅";     
    	String car="小汽车 10 辆"; 
     
        public void fdc(){
                 
        	System.out.println("============父类的房地产公司===========");     
        } 
    } 
    
    //定义子类 
    class S1 extends F1{
         
       public void display(){
         
            System.out.println(money);         
            System.out.println(house);         
            System.out.println(car);         
            fdc();     
       } 
    }

## 1.5、继承中有关构造方法的问题 ##

●在创建有继承关系的子类对象时，会默认先执行父类中默认的构造方法，然后再执行子 类中相关的构造方法。

●如果父类中不存在默认的构造方法，那么此时的解决问题，第一种就是手动添加一个默 认的构造方法；如果此时无法添加默认的构造方法，那又该怎么解决呢？可以使用 super 关键字

package com.bdit; 
    
    public class Test2 {
        
        public static void main(String[] args) {
        
            S2 s2 = new S2(10, 20);
        }
    }
    
    //父类 
    class F2 {
        
    
        public F2(String name) {
        
            System.out.println("==========父类中有参数的构造方法===========");
        }
    
        public F2() {
        
            System.out.println("==========父类中无参数的构造方法===========");
        }
    }
    
    //子类 
    class S2 extends F2 {
        
        public S2() {
        
            System.out.println("============子类中的构造方法=========");
        }
        
        public S2(int n1, int n2) {
        
            System.out.println("=========子类有参数的构造方法=========");
        }
    }

# 2、super关键字 #

前提条件：super 关键字只能出现在有继承关系的子类中

作用：super 表示对当前类父类对象的引用（super 表示的就是父类的某个对象的引用）

super 的第一种用法：super.属性名、super.方法名(参数列表);  
super 的第二种用法：当 super(参数列表)的形式出现在子类构造方法的第一句代码的时 候，就明确指明了通过和参数列表匹配的父类的构造方法，来创建父类对象。

package com.bdit;
    
    public class Test2 {
        
        public static void main(String[] args) {
        
            S2 s2 = new S2(10, 20);
            s2.display();
        }
    
    }
    
    //父类
    class F2 {
        
        String name = "zhangsan";
    
        public F2(String name) {
        
            System.out.println("==========父类中有参数的构造方法===========");
        }
    
        public F2() {
        
            System.out.println("=======父类中无参数的构造方法==========");
        }
    
        public void display() {
        
            System.out.println("父类中的 display 方法");
        }
    }
    
    //子类
    class S2 extends F2 {
        
        String name = "张三";
    
        public S2() {
        
        }
    
        public S2(int n1, int n2) {
        
            super("张三");
            System.out.println("=========子类有参数的构造方法=========");
        }
    
        public void display() {
        
            System.out.println(super.name);
            //调用父类中的方法         
            super.display();
        }
    }

# 继承练习题 #

需求：定义老师类和学生类，然后写代码测试；最后找到老师类和学生类当中的共性内容，抽取出一个父类，用继承的方式改写代码，并进行测试  
步骤：  
①定义老师类(姓名，年龄，教书())  
②定义学生类(姓名，年龄，学习())  
③定义测试类，写代码测试  
④共性抽取父类，定义人类(姓名，年龄)  
⑤定义老师类，继承人类，并给出自己特有方法：教书()  
⑥定义学生类，继承人类，并给出自己特有方法：学习()  
⑦定义测试类，写代码测试

package com.bdit;
    
    public class Test2 {
        
        public static void main(String[] args) {
        
            Teacher teacher = new Teacher("张三", 30);
            teacher.teach();
    
            Teacher teacher1 = new Teacher("李四", 33);
            teacher1.teach();
    
            Student student1 = new Student("小明", 20);
            student1.study();
    
    
            Student student2 = new Student("小红", 19);
            student2.study();
        }
    }
    
    class Person {
        
        String name;
        int age;
    
        public Person(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    }
    
    class Teacher extends Person {
        
    
        public Teacher(String name, int age) {
        
            super(name, age);
        }
    
        public void teach() {
        
            System.out.println(super.name + "老师教 Java，今年" + super.age + "岁");
        }
    }
    
    class Student extends Person {
        
        public Student(String name, int age) {
        
            super(name, age);
        }
    
        public void study() {
        
            System.out.println(super.name + "学习 Java，今年" + super.age + "岁");
        }
    }

猫和狗（ 应用）  
需求：请采用继承的思想实现猫和狗的案例，并在测试类中进行测试

分析：  
①猫： 成员变量：姓名，年龄 构造方法：无参，带参成员方法：get/set 方法，抓老鼠()  
②狗： 成员变量：姓名，年龄 构造方法：无参，带参 成员方法：get/set 方法，看门()  
③共性：  
成员变量：姓名，年龄；构造方法：无参，带参；成员方法：get/set 方法 步骤：

1、定义动物类(Animal)  
【成员变量：姓名，年龄】【 构造方法：无参，带参】【成员方法：get/set 方法】  
2、定义猫类(Cat)，继承动物类  
【构造方法：无参，带参】【成员方法：抓老鼠() 】  
3、定义狗类(Dog)，继承动物类  
【构造方法：无参，带参】【成员方法：看门() 】  
4、定义测试类(AnimalDemo)，写代码测试

package com.bdit;
    
    public class Test3 {
        
        public static void main(String[] args) {
        
            Cat cat = new Cat("小猫", 3);
            cat.catchMouse();
    
            Dog dog = new Dog("小狗", 5);
            dog.lookDoor();
        }
    }
    
    class Animal {
        
        String name;
        int age;
    
        public Animal() {
        }
    
        public Animal(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;
        }
    }
    
    class Cat extends Animal {
        
    
    
        public Cat() {
        }
    
        public Cat(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    
    
        public void catchMouse() {
        
            System.out.println(super.name + "====== 抓老鼠======, 今年 " + super.age);
        }
    }
    
    class Dog extends Animal {
        
    
        public Dog() {
        
    
        }
    
        public Dog(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    
    
        public void lookDoor() {
        
            System.out.println(super.name + "===== 狗看门 =====" + super.age);
        }
    }