构造方法、继承、抽象类、模板设计模式

构造方法、继承、抽象类、模板设计模式
昨天我们讲：定义一个类，类中可以定义两种成员：1).成员属性、2).成员方法
第一章：构造方法【重点】

1.1 构造方法的概念
1).“构造方法”：
构造：指“创建对象—new 对象”；
方法：指“一个方法”。
“构造方法”：指在创建对象时，会被调用的一个方法。
Student stu = new Student();//Student()实际上就是去调用一个“构造方法”
2).在Java中，“任何类”都有“构造方法”，如果我们定义类时，不定义构造方法，编译器会自动为我们的类添加一个“无参、什么都不做”的构造方法。
3).示例代码：
public class Student {
//1.如果我们定义类时，不定义构造方法，编译器会自动为我们的类添加一个“无参、什么都不做”的构造方法【重点记忆】

//2.我们可以自己定义构造方法，编译器就不会再添加任何构造方法了【重点记忆】
/*
    格式：访问权限修饰符   类名([形参]){【重点理解，重点记忆】
                //构造方法的方法体
          }
 */
public Student(){
    System.out.println("无参构造方法...");
}

}
4).构造方法的执行时机：每次创建此类对象时，会被执行。
构造方法的作用：做一些“对象”的初始化。尤其是“带参数”的构造方法，可以为我们的成员属性进行初始化。
class Student{
public void Student(){
System.out.println(“a”);
}
}
main(){
Student stu = new Student();
Student stu2 = new Student();
}
注意：构造方法，一定不能定义“返回值类型”！！！！
1.2 构造方法的重载
1).在一个类中我们可以定义带参的构造方法，也可以同时定义多个构造方法，但形参列表不完全相同——叫：构造方法的重载
作用：方便创建对象——有几个构造方法，就意味着有几种方式创建对象。
2).示例代码：
1).定义Student类：
public class Student {
private String name;
private int age;

//1.如果没有定义构造方法，编译器会自动添加一个"无参、什么都不做"的构造方法。

//2.我们可以自己定义构造方法，而且可以定义带参的
//注意：编译器就不会再添加任何构造方法了
public Student(String name, int age) {
    System.out.println("全参构造...");
    this.name = name;
    this.age = age;
}
//我们也可以同时定义多个构造方法，但形参列表不能完全相同——叫：构造方法的重载。
public Student(){
    System.out.println("无参构造...");
}
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;
}

}
2).定义测试类：
public class Demo02 {
public static void main(String[] args) {
//调用【无参构造】方法，创建对象
Student stu = new Student();
stu.setName(“张三”);
stu.setAge(18);

    System.out.println(stu.getName() + "," + stu.getAge());

    //如果我们定义了带参构造，编译器就不添加任何构造方法了
    //调用【带参构造】
    Student stu1 = new Student("张三", 18);
    //之后就不用再调用setXxx()为成员属性赋值了

    System.out.println(stu1.getName() + "," + stu1.getAge());

}

}

1.3 构造方法的注意事项【重点理解、记忆】
1).Java要求任何类都必须定义“构造方法”——如果我们程序员不定义构造方法，编译器会自动添加一个“无参、什么都不做的”构造方法。
2).如果我们为类定义了构造方法，编译器都不会再添加任何构造方法。
3).构造方法的作用：是在创建对象时调用，用于对成员变量进行初始化的(尤其是带参的构造方法)。
4).构造方法的定义格式：
访问权限修饰符(四种，目前public) 类名 ([形参]){
}
5).构造方法的名字，必须和“类名”相同，不能声明“返回值类型”，构造方法内部也不能“return 值;”，但构造方法中可以写：“return;”表示：结束方法的执行。
6).现在我们要知道，一个类中可以定义三种成员：
public class Student{
//1.成员属性
//2.成员方法
//3.构造方法
}
这三种成员，没有顺序要求，谁在前，谁在后都可以。
第二章：继承【重点】
面向对象语言有三个重要的特征：封装(昨天讲)、继承(今天讲)、多态(下次课)
2.1 继承的概念及作用

1).继承的格式：
		public class 子类名  extends 父类名 {
		}
2).示例代码：

2.2 继承的实现原理
1).子类继承了父类的属性、方法，怎样实现的？不是将父类的属性、方法编译到子类内部了，而是：在子类对象空间内部，会开辟父类对象空间，属性还是存储在父类对象空间内部的。
2).示意图：

2.3 继承中子父类构造器的访问特点
1).上一个知识点我们说过，当new 子类()对象时，会自动调用父类的”无参构造”，其实子类的构造方法的第一行隐式会添加：super()，作用：调用父类无参构造。这句话是必须的，如果我们不写，编译器会自动添加。
2).图示：

3).注意：
	1).super()：代表：调用父类构造方法。
	2).super()必须写在“子类的构造方法”中，而且必须是第一行有效代码。
		所以：super()：调用父类无参构造。
			  super(实参)：调用父类带参构造。
			  这两个方式，只能出现一个，不能同时存在。
	3).通常情况下：子类继承父类后，要观察父类的“构造方法”，通常要参考父类的构造方法，子类也提供一样方式的构造方法。

2.4 继承中子父类成员访问特点及重写的概念
1).子类继承父类后，访问成员特点：先在子类中找，如果有，就用子类的，如果没有，就去父类中找。【重点理解、记忆】

1).“重写”的概念：当子类定义跟父类“一模一样”的方法(返回值类型、方法名、形参列表)，这种形式叫：重写；
	当我们需要保留父类的功能(方法名)，但希望改写父类方法的具体实现，这时我们要重写父类的方法：
	为了避免重写错误，可以使用@Override注解：

2.5 继承的特点
1).父类的“私有”成员(成员属性、成员方法)不能被继承的(可以被子类继承，但不能被子类访问)

2).“父类”的构造方法不能被继承：
	class Human{
		public Human(){
			System.out.println(“a”);
		}
		public Human(String name){
			System.out.println(“b”);
		}
	}
	class Student extends Human{
	}
	//测试类：
	main(){
		Student stu = new Student();//a(Student无参Human无参)
		
		Student stu2 = new Student(“张三”);//编译错误(因为Student没有带参构造方法，父类有，但不能继承)
	}
	==========================================================================================
	class Human{
		public Human(){
			System.out.println(“a”);
		}
		public Human(String name){
			System.out.println(“b”);
		}
	}
	class Student extends Human{
		public Student(String name){
			System.out.println(“c”);
		}
	}
	//测试类：
	main(){
		Student stu2 = new Student(“张三”);//ac(Student的带参构造，没有显示的写super()，会隐式的添加super()，调用父类无参构造
	}
3).Java不允许“多继承”——不允许：子类同时继承多个父类。
		class A{
			public void show(){
				System.out.println(“a”);
			}

}

		class B{
			public void show(){
				System.out.println(“b”);
			}

}
class C extends A,B{//编译错误，不允许同时继承多个父类。
}
4).Java允许“多级继承”：
class A{}//爷爷
class B extends A{}//父辈
class C extends B{}//孙子

	此时B会继承A的允许被继承的成员，C会继承A和B所有允许被继承的成员。

2.6 this和super关键字
1).this可以用在“任何类”中，它可以访问：本类的成员属性、成员方法、构造方法。

	注意：以下情况，必须使用this：
		1).在一个方法中，当它内部的局部变量覆盖成员变量时，要访问被覆盖的成员变量时，这时必须使用“this.成员变量名”访问。
		2).在一个构造方法中，调用另一个构造方法时，必须使用“this([实参])”去调用。
2).super只能用在“子类”中，可以访问父类的：成员属性、成员方法、构造方法：
	
	注意：以下情况，必须使用super：
		1).在子类的构造方法中调用父类构造方法时，必须使用“super([实参])”调用父类构造方法；
		2).在子类的方法中，要访问父类中“被覆盖的成员”，必须使用“super.父类成员名”调用父类被覆盖的成员。

2.7 this的穿透性和super的穿透性
1).this的穿透性：

2).super的穿透性：

第三章：抽象类【重点】

3.1 抽象类的概念
1).抽象：非具体。

抽象类：就是做父类的，不能被创建对象。
抽象方法：由子类继承，并强制子类重写的！！！

3.2 抽象类和抽象方法的定义
1).可以单独定义抽象类：
public abstract class Human{

	}
	注意：可以单独定义抽象类，里面什么都不定义，但没什么意义。“抽象类”不能被创建对象，只能做父类，它也会被编译成class文件。
2).可以在“抽象类”中定义“抽象方法”:
	public abstract class Human{
		......
		public abstract void work();//抽象方法
	}
3).完整的代码：
	1).抽象的父类：

public abstract class Human {
//1.成员属性
private String name;
private int age;
//2.构造方法
public Human() {
}
public Human(String name, int age) {
this.name = name;
this.age = age;
}
//3.成员方法
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;
}
//4.抽象方法
public abstract void work();

}
2).子类：
public class Student extends Human {//继承抽象父类后，必须重写work
@Override
public void work() {
System.out.println(“我叫：” + getName() + “，我今年：” + getAge() + " 我的工作：是学习！！");
}
}
3).测试类：
public class Demo13 {
public static void main(String[] args) {
Student stu = new Student();
stu.setName(“郭德纲”);//调用父类的
stu.setAge(18);//调用父类的

    stu.work();//子类重写的
}

}

3.3 抽象类的特点
1).抽象类：不能被创建对象，就是被子类继承的——代码复用；
2).抽象类：里面可以定义：
public abstract class Human{
//1.成员属性
//2.构造方法
//3.成员方法
//4.抽象方法
}
3).抽象类不能创建对象，但可以有构造方法——构造方法的作用：初始化成员属性。
4).抽象类中可以不定义任何成员。
5).抽象类中可以不定义抽象方法；但如果定义抽象方法，此类必须定义为“抽象类”。
6).子类继承抽象类仍然使用extends关键字，而且仍然是“单继承”。当子类继承抽象类后，必须重写抽象类中所有的抽象方法，否则子类必须被生命为抽象类。
抽象类子抽象类
抽象类普通子类
普通父类子抽象类【可以】

3.4 模板设计模式
1).什么是“模式”：例如：经营模式、学习模式、盈利模式…，这些现实中的“模式”都是：为了解决某种问题，而提出的一套“标准的解决方案”(但不一定是唯一方案)。
2).什么是“Java设计模式”：指在开发过程中，为了解决开发中的一些问题，而利用Java的一些语法特征而设计的一套“解决方案”。
3).“模板设计模式”：
A).解决的问题：基于Java的：继承、抽象类的这种语法，设计出的一种“模板”——由父抽象类设计出大部分的内容，由子类去填充少部分的其他内容，构成一个完整的内容。
B).利用的语法：继承、抽象类、抽象方法
4).案例：描述一个司机开车的几个标准流程：开门、点火、开车、刹车、熄火
程序中需要定义两个“类”：“老司机”类，“新司机”类
“老司机”类要求：开门、点火、左手抽烟，右手握方向盘、刹车、熄火
“新司机”类要求：开门、点火、双手紧握方向盘、刹车、熄火
我们发现：只有中间”开车”的步骤不同，其他的都是一样的，所以这样我们就可以设计一个“父类”作为：模板，实现大部分内容，由子类填充不同的开车的内容。

总结：
1.能够知道构造方法的格式和注意事项
1).格式：
访问权限修饰符 类名([形参]){
}
2).注意事项：
1).Java要求任何类都必须定义“构造方法”——如果我们程序员不定义构造方法，编译器会自动添加一个“无参、什么都不做的”构造方法。
2).如果我们为类定义了构造方法，编译器都不会再添加任何构造方法。
3).构造方法的作用：是在创建对象时调用，用于对成员变量进行初始化的(尤其是带参的构造方法)。
4).构造方法的定义格式：
访问权限修饰符(四种，目前public) 类名 ([形参]){
}
5).构造方法的名字，必须和“类名”相同，不能声明“返回值类型”，构造方法内部也不能“return 值;”，但构造方法中可以写：“return;”表示：结束方法的执行。
6).现在我们要知道，一个类中可以定义三种成员：
public class Student{
//1.成员属性
//2.成员方法
//3.构造方法
}
这三种成员，没有顺序要求，谁在前，谁在后都可以。
2.能够写出类的继承格式
public class 子类 extends 父类{
}
3.能够说出继承的特点
1).父类的“私有”成员可以被继承，但不能被子类访问(也相当于不能被继承)
2).父类“构造方法”不能被子类继承。
3).Java不允许“多继承”；
4).Java允许“多级继承”；

4.能够说出子类调用父类的成员特点
先在子类中找，如果有，就用子类的，如果没有，就去父类中找。
5.够说出方法重写的概念
子类定义了跟父类一模一样的方法，这种形式叫：方法重写。【区别于：方法重载】
为了保证重写正确，可以使用：@Override注解
6.能够说出this可以解决的问题
this可以访问：本类成员属性、成员方法、构造方法。
必须使用this：
1).在方法中，局部变量覆盖成员变量，要访问被覆盖的成员变量，必须用“this.成员变量”的方式；
2).在一个构造方法，调用另一个构造方法必须使用“this([实参])”的方式；
7. 能够说出super可以解决的问题
super可以访问：父类的成员属性、成员方法、构造方法
必须使用super：
1).在子类中，子类的成员覆盖了父类的成员，要访问被覆盖的父类成员，需要使用“super.父类成员”的形式。
2).在子类的构造方法中，调用父类的构造方法，必须使用“super([实参])”的形式。
8.描述抽象方法的概念
1).用abstract修饰的方法；
2).不能有方法体(不能有一对大括号)
3).作用：被子类继承，并强制重写。
9. 写出抽象类的格式
public abstract class Human{
}
10.写出抽象方法的格式
public abstract class Human{
public abstract void work();
}
11.能够说出父类抽象方法的存在意义
要求子类必须继承，并必须重写！！