java继承中的构造方法使用

java继承中的构造方法

引入封装的基本概念

一、封装

1、什么是封装
******封装,就是隐藏对象的属性和实现细节把属性都隐藏,通过这些公有方法访问私有属性，其中public -> protected -> default -> private（开放程度由大到小，安全性由低到高）
2.属性封装的实现

• 修改属性的可见性来限制对属性的访问
• 为每个属性创建一对赋值(setter)方法和取值(getter) 方法，用于对这些属性的访问
• 在setter(存的限制)和getter(取的限制)方法中，加入对属性的存取限制

3.代码封装的好处

• 使用封装，增加了数据访问限制，增强了程序的可维护性
• 将变化隔离
• 便于使用（不用了解内部构造，就完成了操作。）
• 提高重用性
• 提高安全性

二、构造函数

1.构造方法的作用

• 构造方法负责对象成员的初始化工作，为实例变量赋予合适的初始值
• 要简化对象初始化的代码，可以通过构造方法来解决
• 创建对象
• 初始化成员变量

2.构造方法的语法规则

• 方法名与类名相同
• 没有返回类型
• 使用new关键字调用构造方法

3.两种构造方法
（1）带参数的构造方法：
通过调用带参数的构造方法，简化对象初始化的代码

（2）无参数的构造方法

注意：
（1）构造方法的调用时机:在new对象的时候，会调用构造方法
如果定义一个类，没有添加构造方法的话？
由jvm帮助我们添加一个无参的构造方法
如果有构造方法的话，不会添加无参的构造方法

在这个测试类中通过new创建了一个p1对象，其实引用了无参数的构造方法，是jvm帮我们在类中添加了无参的构造

类中的无参数的构造函数应如下所示：

如果一个无参的构造方法被私有（private），那不会创建对象，因为 private不会出本类
![测试类](https://img-blog.csdnimg.cn/20200723195959129.png

可以看出，当我们把功能类（Person）中的public改为private后，测试类所创建的对象不能够成功，因为检测不到Person类中对象的存在。

三、继承

1.继承的作用
使用继承提高代码的复用性
使用多态提高代码的可扩展性及可维护性

• 1.提高代码的复用性
• 2.正是因为有了继承，才有了后面的多态

2.如何实现继承
（1）子类的构造方法中，通过super关键字调用父类的构造方法
（2）通过调用父类的构造方法，完成对属性值的初始化
（3）方法重写后，通过super关键字调用父类的方法
java中一切的类引入从根源来说，全都来源于Object（一切类的祖先）

3.子类与父类
（1）is-a，父类更通用、子类更具体
（2）子类具有父类的一般特性（包括属性和行为），以及自身特殊的特性
（3）super:当前对象的直接父类的引用
（4）父类：被重写方法 子类：重写方法

四、两个实例，面向继承中的构造方法

实例一（教师类）

/**
*Teacher.java(以下JavaTeacher.java和DotNetTeacher.java的父类)
*模拟上课的状态
*/
package extendyes;

public class Teacher {
	//隶属中心
	private String school;
	//姓名
	private String name;
	/**
	 * 创建对象并初始化成员变量
	 * @param school 要设置的中心
	 * @param name 要设置的姓名
	 */
	public Teacher(String school,String name){
		this.school=school;
		this.name=name;
	}
	/**
	 * 自我介绍
	 */
	public void introduction(){
		System.out.println("大家好！我是来自于"+this.school+"中心的"+this.name+"老师");
	}
	/**
	 * 授课
	 */
	public void giveLesson(){
		System.out.println("实施理论课教授...");
	}
}

/**
*JavaTeacher.java（java老师的信息）
*/
package extendyes;

/**
 * JavaTeacher 继承于 Teacher
 * super:当前对象的直接父类的引用
 * @author Administrator
 *
 */
public class JavaTeacher extends Teacher {
	
	/**
	 * 初始化隶属中心和姓名两个属性
	 * @param school 要设置的隶属中心
	 * @param name 要设置的姓名
	 */
	public JavaTeacher(String school, String name) {
		//调用父类的构造方法,来完成我的初始化工作
		super(school, name);
	}
	/**
	 * 授课   父类：被重写方法 子类：重写方法
	 * 两者应保持一致
	 */
	public void giveLesson(){
		System.out.println("打开Eclipse...");
		//调用父类的授课方法
		super.giveLesson();
	}
}

/**
*DotNetTeacher.java
*/
package extendyes;

public class DotNetTeacher extends Teacher {
	/**
	 * 初始化成员变量
	 * @param school 要设置的隶属中心
	 * @param name 要设置的姓名
	 */
	public DotNetTeacher(String school,String name){
		//调用父类的方法完成初始化
		super(school,name);
	}
	public void giveLesson(){
		System.out.println("打开VS2015...");
		//调用父类的授课方法
		super.giveLesson();
	}
}

/**
*TestTeacher.java(测试类)
*/
package extendyes;

/**
 * 继承的作用：
 * 1.提高代码的复用性
 * 2.正是因为有了继承，才有了后面的多态
 * @author Administrator
 *
 */
public class TestTeacher {

	public static void main(String[] args) {
		//创建一名java老师
		JavaTeacher jt = new JavaTeacher("北京", "令狐冲");
		//自我介绍
		jt.introduction();
		//授课
		jt.giveLesson();
		//创建一名DotNet老师
		DotNetTeacher dt = new DotNetTeacher("西安", "东方不败");
		//自我介绍
		dt.introduction();
		//授课
		dt.giveLesson();
	}
}

效果如下：

实例二（工人类）

/**
*Person.java(以下Worker.java的父类)
*/
package extendyes;

public class Person {
	//姓名
	private String name;
	//年龄
	private int age;
	/**
	 * 获取姓名
	 * @return 姓名
	 */
	public String getName(){
		return this.name;
	}
	/**
	 * 构造方法，初始化成员变量
	 * @param name 要设置的姓名
	 * @param age 要设置的年龄
	 */
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "姓名:"+this.name+"\n年龄:"+this.age;
	}
}

/**
*Worker.java(创建一名工人类，输出他的基本信息和薪水)
*其中，成员变量salary（薪水）并不继承于父类
*/
package extendyes;

public class Worker extends Person{
	//薪水
	private double salary;
	/**
	 * 初始化姓名和年龄
	 * @param name 要设置的姓名
	 * @param age 要设置的年龄
	 */
	public Worker(String name,int age){
		super(name,age);
	}
	/**
	 * 初始化姓名和年龄,薪水
	 * @param name 要设置的姓名
	 * @param age 要设置的年龄
	 * @param salary 要设置的薪水
	 */
	public Worker(String name,int age,double salary){
		//调用本类的构造方法
		this(name,age);
		//设置薪水
		this.salary=salary;
	}
	/**
	 * 上班
	 */
	public void working(){
		System.out.println(this.getName()+"正在兢兢业业地上班...");
	}
	@Override
	public String toString() {
		return "我是一名工人;"+super.toString()+"\n薪水："+this.salary;
	}
}

/**
*TestPerson.java(测试类)
*其中对象p1表示普通人（成员变量全部来源于父类）
*对象w1表示工人，基本姓名、年龄基本信息来源于父类，薪水这个成员变量是
子类的特有属性
*/
package extendyes;

public class TestPerson {

	public static void main(String[] args) {
		//创建一个人
		Person p1 = new Person("张无忌", 28);
		//说明一下
		System.out.println(p1);
		//创建一名工人
		Worker w1 = new Worker("任盈盈", 18,8000);
		//w1说明一下
		System.out.println(w1);
		//上班
		w1.working();
	}
}

效果如下：