学习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) {
	
	}
}

package bank;
import bank.person.*;
class Manager{
	String account;
	int id;
	
	public static void main (String[] args) {
		Customer cus = new Customer();
	}
}

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) {
		
	}
}

(默认类)

package bank;
import bank.person.*;
class Manager{
	String account;
	int id;
	
	public static void main (String[] args) {
		Customer cus = new Customer();
	}
}

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;
	}
}

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个），以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、如何实现继承？

• 将共同的代码编写一个类
• 将个体代码分别编写类
• 个体代码继承共同代码类
  如何继承？关键字：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;
	}
}

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、概念

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

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();
	}
}

2、动态多态性

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

• 两种使用情况
  -（1）形参定义父类类型，实参可以传入子类对象
  FontDialog是Dialog的子类
  void fun(Dialog d){ /**/ } 函数定义
  fun(new FontDialog); 函数调用
  案例：有FontDialog和ParaDialog两个类，在主界面类中，定义一个函数，可以将对话框在界面中居中。

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

-（2）函数返回父类类型，实际返回子类对象
FontDialog是Dialog的子类
Dialog fun(){ 函数定义
return new FontDialog();
}
Dialog d = fun();
d.show(); 函数调用

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();
		ParaDialog pd = new ParaDialog();
		mf.toCenter(pd);
	}
}

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(){
		
	}
}