学习JAVA第四课：封装、继承以及多态性

突然就开始学JAVA了，很不习惯啊，但是再不学课设就要玩完了呜呜呜呜

---

封装（Encapsulation)

面向对象的基本特征
将用户需要的内容暴露，隐藏细节；将内容分门别类进行管理

1、包级封装：将类分门别类放在包中，便于管理

• 如何将类放在某个包中(以文件夹进行管理)
  在类的定义上，标明： package 包名;
  要点：
• 编程规范：包的名字首字母一般小写
• 可以定义包中的子包，定义时用 . 隔开
• 用.定义的子包，和上层的包，并无隶属关系，只是各自的包名定义 bank bank.person 不是包含关系，这两个包是不同的包

如何使用某个包中的类

• 同一个包中的类，可以直接使用
• 不在同一个包中的类，需要用
  import 类路径 来导入。（前提：被导入的类是public类）
  import 包名.*; 导入包中的所有类

如下：

package bank.person;
class Customer{
	String account;
	double balance;
	
	public static void main (String[] args) {
	
	}
}
1
2
3
4
5
6
7
8
9

package bank;
import bank.person.*;
class Manager{
	String account;
	int id;
	
	public static void main (String[] args) {
		Customer cus = new Customer();
	}
}
1
2
3
4
5
6
7
8
9
10

2、类级封装

主要特指：前面所述的 public类
public类在定义时，增加public关键字 public class XX{}

• 规定：public类类名必须和类所在文件名相同
• 性质：只有public类才能被包外的类导入并访问，普通类只能在同一个包中被访问

如下：
(public类)

package bank.person;
public class Customer{
	String account;
	double balance;
	
	public static void main (String[] args) {
		
	}
}
1
2
3
4
5
6
7
8
9

(默认类)

package bank;
import bank.person.*;
class Manager{
	String account;
	int id;
	
	public static void main (String[] args) {
		Customer cus = new Customer();
	}
}
1
2
3
4
5
6
7
8
9
10

3、成员级封装：定义各个成员被外界访问的权限

权限有4种：

• private：私有 只在类中能被访问
• 无修饰：默认 能在类中访问；也可被同一包中其他类访问
• protected：保护 默认权限+可被包外子类访问
• public：公开 可被包内包外所有类访问
  要点：
• 建议：成员变量定义成私有；成员函数定义成公有
• 通过成员函数来访问成员变量，确保访问安全

如下：

package bank.person;
public class Customer{
	String account;
	private double balance;
	public void display(){}
	public static void main (String[] args) {
		Customer cus = new Customer();
		cus.balance = 1000;
	}
}
1
2
3
4
5
6
7
8
9
10

package bank;
import bank.person.*;
class Manager{
	String account;
	int id;
	
	public static void main (String[] args) {
		Customer cus = new Customer();
		//cus.balance = 1000;
		//cus.account = "zs";
		cus.display();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

习题

编写代码，实现单例模式（某个对象在系统使用的过程中，永远保持不多于1个），以Windows的任务管理器为例

class TaskManager{	
	private static TaskManager tm = null;	
	private TaskManager(){  
		System.out.println("任务管理器初始化");
	}
	public static TaskManager getInstance(){
		if(tm==null)  { tm = new TaskManager();}
		return tm;
	}
	public void display()   {	System.out.println("任务管理器显示");}
}

class Desktop{
	public void click(){				
		TaskManager.getInstance().display();		
	}
	public static void main (String[] args) {
		Desktop d = new Desktop();
		d.click();		d.click();		d.click();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

继承

1、为什么需要继承

降低代码量，提高系统可维护性
1

2、如何实现继承？

• 将共同的代码编写一个类
• 将个体代码分别编写类
• 个体代码继承共同代码类
  如何继承？关键字：extends

要点：

• （1）FontDialog继承Dialog，FontDialog叫做子类，派生类或者扩展类；Dialog又叫做父类，基类或者超类
• （2）子类继承父类之后，父类中的成员可以像子类自己的成员一样被子类对象使用（私有的父类成员除外）
• （3）如果父类成员被子类使用，一般将父类成员定义为protected
• （4）Java不支持多重继承（同时继承多个父类）

class Dialog{
	int w;
	int h;
}
class FontDialog extends Dialog{
	String fontName;
}
class ParaDialog extends Dialog{
	int lineWidth;
}

class Test{	
	public static void main (String[] args) {
		FontDialog fd = new FontDialog();
		fd.w = 100;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3、子类中可否定义和父类格式相同的成员？

• 可以；此时子类对象调用时子类中的成员
• 该内容称为“覆盖”（override）,或者“重写”
  要点：
• 覆盖时，不允许使得子类成员的访问权限更加严格

4、覆盖有何作用？

• 可以通过覆盖，实现子类对象某些属性或功能的个性化定制

5、如何在子类中调用父类成员？

• 用super来指代父类对象，调用相应成员
• super和this是对应的

class Dialog{
	int w;
	int h;
	public void show(){
		System.out.println("Dialog显示");
	}
}
class FontDialog extends Dialog{
	String fontName;
	public void show(){
		super.show();
		System.out.println("FontDialog显示");
	}
}
class Test{	
	public static void main (String[] args) {
		FontDialog fd = new FontDialog();
		fd.show();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

多态性

1、概念

• 多态性：一个事物，在不同情况下呈现出不同形态
• 重载： 一个函数名，在不同参数传入下，实现不同功能
  重载属于“静态多态性”；静态体现在：必须为多个函数功能编写相应函数

class Dialog{
	public void show(){	System.out.println("Dialog.show");	}
}
class FontDialog extends Dialog{
	public void show(){	System.out.println("FontDialog.show");	}
}
class Test{	
	public static void main (String[] args) {
		Dialog d = new FontDialog();
		d.show();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

2、动态多态性

• 基本规则：父类引用可以指向子类对象
• 性质：父类引用调用被覆盖的成员时，调用的是子类对象中的成员

两种使用情况
（1）形参定义父类类型，实参可以传入子类对象
FontDialog是Dialog的子类
void fun(Dialog d){ /**/ } 函数定义
fun(new FontDialog); 函数调用
（2）函数返回父类类型，实际返回子类对象
FontDialog是Dialog的子类
Dialog fun(){ 函数定义
return new FontDialog();
}
Dialog d = fun();
d.show(); 函数调用

案例：有FontDialog和ParaDialog两个类，在主界面类中，定义一个函数，可以将对话框在界面中居中。

class Dialog{
	public void show(){	System.out.println("Dialog.show");	}
}
class FontDialog extends Dialog{
	public void show(){	System.out.println("FontDialog.show");	}
}
class ParaDialog extends Dialog{
	public void show(){	System.out.println("ParaDialog.show");	}
}

class MainFrame{	
	public void toCenter(Dialog d){
		/*计算界面坐标*/
		d.show();
	}
	public static void main (String[] args) {
		MainFrame mf = new MainFrame();
		MyNewDialog mnd = new MyNewDialog();
		mf.toCenter(mnd);
	}
}
class MyNewDialog extends Dialog{
	public void show(){
		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

案例：编写一个类似Word的软件，窗口上点击菜单，出现一个“字体对话框”。
如果用户想要开发一个新的对话框，怎么办？

class Dialog(){
	public void show(){}
}

class FontDialog extends Dialog{
	pubilc void show()
	{
		System.out.println("FontDialog显示");
	}
}

class Window{
	public void cilckMenu(Dialog d){
		d.show();
	}
	public static void  main(String[]args){
		Window w = new Window();
		w.clickMenu(new MyFontDialog());
	}
}
class MyFontDialog extends Dialog{
	public void show()
	{
		System.out.println("自己编写的好看的Dialog就有了")
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

多态性体现在：一个父类引用，在不同子类对象被指向的情况下，完成相应子类的功能。
该思想是软件支持“不修改源代码的情况下二次开发”以及“不修改源代码的情况下，模块可拼装”的基础。将两个业务类的关系变远，这叫做软件工程里的“低耦合”。

• 多态性：一个事物，在不同情况下呈现出不同形态
• 重载： 一个函数名，在不同参数传入下，实现不同功能
• 动态多态性：一个函数，在不同子类对象参数传入情况下，实现不同功能

抽象函数：
在函数前面增加abstract关键字，该函数原则上要被重写，否则报错。

• 含有抽象函数的类就叫做抽象类，用abstract修饰
• 抽象函数必须被重写，除非该子类也是一个抽象类
• 抽象函数没有函数体（类似c++里的纯虚函数）
• 抽象类不能被实例化

问题：
1、抽象类中可以有普通函数吗？
可以
2、抽象类中是否可以写构造函数？
不可以
3、抽象类不能被实例化，那它的构造函数和普通函数有什么用？
构造函数可以初始化某些变量，普通函数可以被子类重用
4、抽象函数必须重写吗？
不一定，如果子类也是个抽象函数的话

抽象类、抽象函数是一种：标准化手段
1

抽象类中可以有普通的函数，抽象类可以拥有一些自己的功能。
再介绍一种比抽象类更抽象的“抽象类”，叫做接口（interfance）
interfance和抽象类类似，只不过它里面所有的内容只能是抽象函数，所有的变量只能是常量。

关于接口：
1、接口中所有变量都是常量，所有函数都是抽象函数，abstract可以省略
2、接口中的所有成员都是public的。public可以省略
3、接口中的任何变量都是常量，并且是静态常量
4、一个类最多只能继承一个抽象类，但可以实现多个接口，逗号隔开

interface Dialog1{
	void show1();
}

interface Dialog2{
	void show2();
}
class FontDialog implements Dialog1,Dialog2{
	public void show1(){
		System.out.println("show1显示");
	}
	public void show2(){
	System.out.println(Dialog2.a);
		System.out.println("show2显示");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

为什么叫“接口”呢？
起到连接作用，又是候也叫做“界面”。

3、其他内容

final关键字
在类、成员变量和成员函数之前增加final关键字
类前面增加final关键字，则该类不能有子类
在成员函数前增加final，则该函数不能被重写
在成员变量前加final，则该成员变量是常变量，必须提前赋值，不能改变其值

Object类
java中任何一个子类都是Object子类。
该类有两个小作用：
Object类中，有一个toString方法，可以给子类一个以字符串展示的机会。
Objiect类中，有一个equals方法，可以给子类对象一个比较他们是否相等的机会。
两个对象名，a==b，除非a和b指向同一个对象，才返回true
如果自定义两个对象内容相等呢？就可以重写equals方法

class Customer{
	String cname;
	String password;
	String account;
	double balance;
	public String toString()
	{
		return account + "-" + cname +"-"+balance;
	}
	public static void main()
	{
		Customer  zs = new Customer();
		System.out.println(zs);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class Customer{

	String account;
	double balance;
	public boolean equals(Customer c)
	{
		if(cname.equals(c.cname)&&balance.equals(c.balance))
		{
			return true;
		}
		return false;
	}
	public static void main()
	{
		Customer  zs = new Customer();
		zs.cname  = "zhangsan";
		zs.balance = 1000;
		Customer  ls = new Customer();
		zs.cname = "lisi";
		ls.balance = 1000;

	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

练习：详细讲解多态性的应用

编写一个按钮，具有点击功能，编写一个按钮，上面有一个按钮，点击按钮，让窗口变红。模拟代码即可。

class Button{
	ButtonListener bl;
	public void bind(ButtonListener bl) {
		this.bl=b;
	}
	public void click() {bl.action();}
}

interface ButtonListener{
	public void  action();
}
class Window implements ButtonListener{
	Button b = new Button();
	public void action()
	{
		this.toRed();
	}
	public Window()
	{
		b.bind(this);
	}
	public void toRed()
	{
		System.out.println("窗口变红");
	}
	public static void main (String[] args) {
		Window w= new Window();
		w.b.click();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30