面向对象——继承

墨蓝 2022-05-22 13:28 329阅读 0赞

# 继承的特点 #

1，描述类与类之间的关系

2，降低类和类之间的重复代码

3，降低对象和对象之间的代码重复使用静态变量

4，降低类与类之间的代码重复使用就用继承

# extends关键字 #

继承使用extends关键字实现，

1：发现学生是人，工人是人。显然属于is a 的关系，is a就是继承。

2：谁继承谁？

学生继承人，发现学生里的成员变量，姓名和年龄，人里边也都进行了定义。有重 复代码将学生类的重复代码注释掉，创建学生类对象，仍然可以获取到注释的成员。这就是因为继承的关系，学生类（子类）继承了人类（父类）的部分

代码例：

class Person {
    	String name;
    	int age;
    
    	// 静态变量（类变量）对象和对象之间的代码重复使用静态变量
    	static String country = "CN";
    
    	Person() {
    
    	}
    
    	void speak() {
    		System.out.println(name + ":哈哈，我是人！！！");
    	}
    
    }
    
    // 让学生类和人类产生关系，发现学生is a 人，就可以使用继承
    class Student extends Person {
    
    	Student() {
    
    	}
    
    	void study() {
    		System.out.println("姓名：" + name + "年纪：" + age + ":好好学习");
    	}
    }
    
    class Worker extends Person {
    
    	void work() {
    		System.out.println(name + ":好好工作，好好挣钱。");
    	}
    
    }
    
    class Demo1 {
    
    	public static void main(String[] args) {
    		Student stu = new Student();
    		stu.name = "jack";
    		stu.age = 20;
    		stu.study();
    		stu.speak();
    		System.out.println(stu.country);
    		System.out.println(Student.country);
    
    		Worker worker = new Worker();
    		worker.name = "rose";
    		System.out.println(worker.country);
    		worker.work();
    		worker.speak();
    
    		System.out.println();
    	}
    }

# 继承的细节 #

1，类名的设定，被继承的类称之为父类（基类），继承的类称之为子类

2，子类并不能继承父类中所有的成员

1，父类定义完成的成员，静态成员，非静态，构造方法。静态变量和静态方法都可以通过子类名，父类静态成员的形式调用成功

2，所有的私有成员不能继承，就是private修饰的成员

3，构造函数不能被继承

3，如何使用继承

1，不要为了使用继承而击沉而过。工人和学生都是共性的成员，不要为了节省代码，让工人继承学生

/*
    如何使用继承：验证是否有 is  a 的关系
     例如：学生是人， 小狗是动物
     注意：不要为了使用某些功能而继承,java只支持单继承
     */
    class DK {
    
    	void Ip4S() {
    		System.out.println("好玩");
    	}
    }
    
    class BGir extends DK {
    
    }
    
    class Demo {
    
    	public static void main(String[] args) {
    
    		new BGir().Ip4S();
    
    	}
    }

# super关键字 #

例

1：定义Father(父类)类
    		1：成员变量int x=1;
    		2：构造方法无参的和有参的，有输出语句
    	2：定义Son类extends Father类
    		1：成员变量int y=1;
    		2：构造方法无参和有参的。有输出语句
    		1：this.y=y+x;
    	3：创建Son类对象
    		Son son=new Son(3);
    		System.out.println(son.y); //4
    class Father {
    	int x = 1;
    
    	Father() {
    		System.out.println("这是父类无参构造");
    	}
    
    	Father(int x) {
    
    		this.x = x;
    		System.out.println("这是父类有参构造");
    	}
    
    	void speak() {
    		System.out.println("我是父亲");
    	}                  
    }
    
    class Son extends Father {
    	int y = 1;
    
    	Son() {
    		System.out.println("这是子类的无参构造");
    	}
    
    	Son(int y) {
    
    		this.y = y + x;
    		System.out.println("这是子类的有参构造");
    	}
    
    	void run() {
    		super.speak(); // 访问父类的函数
    		System.out.println("我是儿子");
    	}
    }
    
    class Demo6 {
    
    	public static void main(String[] args) {
    		Son s = new Son(3);
    		System.out.println(s.y);// 4
    	}
    }

4：子类对象为什么可以访问父类的成员。

1：this.y=y+x;有一个隐式的super super.x

5：super关键字作用

1：主要存在于子类方法中，用于指向子类对象中父类对象。

2：访问父类的属性

3：访问父类的函数

4：访问父类的构造函数

6：super注意

this和super很像，this指向的是当前对象的调用，super指向的是当前调用对象的父类。Demo类被加载，执行main方法，Son.class加载，发现有父类Father类，于是Father类也加载进内存。类加载完毕，创建对象，父类的构造方法会被调用（默认自动无参），然后执行子类相应构造创建了一个子类对象，该子类对象还包含了一个父类对象。该父类对象在子类对象内部。this super只能在有对象的前提下使用，不能在静态上下文使用。

2：子类的构造函数默认第一行会默认调用父类无参的构造函数，隐式语句

super();

1：父类无参构造函数不存在，编译报错。

Son(int y) {
    		//super();隐式语句
    		this.y = y + x;
    		System.out.println("这是子类的有参构造");
    	}

3：子类显式调用父类构造函数

在子类构造函数第一行通过super关键字调用父类任何构造函数。如果显式调用父类构造函数，编译器自动添加的调用父类无参数的构造就消失。构造函数间的调用只能放在第一行，只能调用一次。super() 和this()不能同时存在构造函数第一行。

Son(int y) {
    		super(y);// 子类显式调用父类构造函数
    		this.y = y + x;
    		System.out.println("这是子类的有参构造");
    	}
    
    Son(int y) {
    		this();  //不能同时存在构造函数第一行  
    		super(y);
    		this.y = y + x;
    		System.out.println("这是子类的有参构造");
    	}