株所实习第五天（继承组合，final，封装，多态）

记录11.19的学习内容

1.继承和组合

作用：

继承：代码的复用，方便建模（is a）；
组合：代码的复用，方便建模（has a）；
（他们的区别可以理解为所属关系，在继承里可以理解为我是个学生，而在组合里可以理解为我和我的手之间的关系）

继承举例：

创建一个School类

public class School {

	String name;
	public School() {
		super();
	}
	void lesson() {
		System.out.println("Meth");
	}
}

class Class1 extends School {
	
	void lesson1() {
		this.lesson();
		System.out.println("----------------");
		System.out.println("English");
	}
}

创建一个Test1类

public class Test1 {

	public static void main(String[] args) {
		School s = new School();
	//	s.lesson();
		
		Class1 c = new Class1();
		c.lesson1();
		
	}
}

输出的结果

Meth
----------------
English

组合举例：

创建一个People类

public class People {
	String name;
	public People() {
		super();
	}
	void student() {
		System.out.println("I am a student!");
	}
}

class Sheldon {
	People people = new People();
	public Sheldon() {
		super();
	}	
	void student() {
		people.student();
		System.out.println("---------------");
		System.out.println("I am a student,too!!");
	}
}

创建一个Test类

public class Test {
	public static void main(String[] args) {
		Sheldon s = new Sheldon();
		s.student();
		s.people.student(); // 也可以通过该方式调用People的student方法
	}
}

输出的结果

I am a student!
---------------
I am a student,too!!
I am a student!

从上面的结果看来，组合类似于多继承，可以一次使用多个类，更加的灵活方便。

---

2.final关键字

作用：

可用于修饰变量、方法、类

1. 修饰变量：变量不可以修改（不能改变值），只能初始化一次。
2. 修饰方法：方法不可以重写（override），但是可以重载（overlord）。
3. 修饰类：类不可以被继承。

Final修饰成员变量时，有三种赋值方式

1. 在声明时进行直接赋值。
2. 在构造器中赋值。
3. 在初始化代码块中进行赋值。

---

3.面向对象——封装（隐藏）与访问修饰符

JAVA面向对象的三大特征：封装，继承，多态

作用：

隐藏对象内部的复杂性，只对外公开简单的接口，便于外界的调用，从而提高系统的可拓展性，可维护性。

“高内聚（类的内部数据操作细节自己完成，不允许外部干涉），低耦合

JAVA的访问修饰符有四个：private、default、protected、public。

（他们之间的区别在于访问的限制）

1. public：所有类。
2. protected：子类。
3. default：同一个包中。
4. private：同一个类。

Tips：常量与静态一般情况下使用public。

---

4.面向对象——多态（Polymorphism）

JAVA面向对象的三大特征：封装，继承，多态

多态即对象具有多种形态。具体而言，是编译时类型和运行时类型。

编译时类型：由声明时的类型决定的，一般来说都是父类。
运行时类型：由实际对应的对象类型决定，具体是哪个子类就是哪个子类。

特点：

多态性是OOP（面向对象程序设计Object Oriented Programming）中的一个重要特性，它的主要作用是用来实现动态连编的，换句话说，程序的最终状态只有在执行程序的过程中才会被确定，而不是在编译期间就决定了的。这样的机制对于大型系统来说能非常有效的提高系统的灵活性与可拓展性。

三个必要条件：

1. 继承。
2. 方法重写。
3. 父类引用指向子类对象。

---

2019年11月20日，晴