黑马程序员—面向对象（二）

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、设计模式

设计模式：解决某一类问题最行之有效的方法。

Java中有23种设计模式：
单例设计模式：解决一个类在内存只存在一个对象。
想要保证对象唯一：

1，为了避免其他程序过多建立该类对象，先禁止其他程序建立该对象。

2，还为了让其他程序能够访问到该类的对象，只好在本类中自定义一个对象。

3，为了方便其他程序对自定义的对象的访问，可以对外提供一些访问方式。

这三步用代码体现的方法：

1，将构造函数私有化。

2，在类中创建一个本地对象。

3，提供一个方法可以获取到该对象。

/*
饿汉式单例设计模式：类一加载，对象就在堆中建立。
*/
class Single
{
	private Single(){}
	private static Single s = new Single();
	public static Single getInstanse()
	{
		return s;
	}
	public static void main(String[] args)
	{
		Single s1 = Single.getInstanse();
		Single s2 = Single.getInstanse();//s1与s2都指向同一个对象。
	}
}
/*
懒汉式单例设计模式：对象调用方法时被调用才初始化，也叫做对象的延时加载。
Single类进内存，对象还没有存在，只有在调用了getInstance方法时，对象才建立。
*/
class Single1
{
	private Single1(){}
	private static Single1 s = null;
	public static Single1 getInstanse()
	{
		if(s == null)
			s = new Single1();
		return s;
	}
	public static void main(String[] args)
	{
		Single1 s1 = Single1.getInstanse();
		Single1 s2 = Single1.getInstanse();//s1与s2都指向同一个对象。
	}
}

对于事物怎么描述，还怎么描述，当需要将该事物的对象保证在内存中唯一时，就将以上三步加入到类中。

定义单例设计模式建议使用饿汉式单例设计模式。

二、继承

继承：

1，提高代码的复用性。

2，让类与类之间产生了关系，有了这个关系，才有了多态的特性。

注意：千万不能为了把其他类的功能，简化代码而继承。必须是类与类之间具有关系才可以继承。所属关系 is a。
 
Java中不支持多重继承
因为多重继承容易带来安全隐患，当多个父类中定义了相同的功能，当功能内容不同时，子类对象不确定要运行哪一个。但是Java保留了这种机制。并用另一种体现形式来完成，多实现（接口）。
Java支持多层继承，也就是一个继承体系。
想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中的共性功能。通过了解共性功能就可以基本了解该体系的特性。那么这个体系已经可以基本使用了。那么在具体调用时，要创建子类的对象。
简单来说就是查阅父类，使用子类。

3.子父类中的变量

a.如果子类中出现非私有的同名变量时，子类要访问本类中的变量，用this，子类要调用父类中的同名变量时，使用super。

b.super的使用和this的使用几乎一致。this代表的是本类的对象的引用，super代表的是父类对象的引用。

4.子父类中的函数

a.当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容。如同父类的函数被覆盖一样，这种情况是函数的一个特性：重写（覆盖）。

b.当子类继承父类，沿袭了父类的功能，到子类中，但是子类虽具备该功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。

覆盖：

1，子类覆盖父类，必须保证子类权限大于等于父类的权限，才可以覆盖，否则编译失败。

2，静态只能覆盖静态

3.子父类中的构造函数

重载：只看同名函数的参数列表。
重写：子父类方法要一模一样（权限、返回值类型都要一样）。
在对子类对象进行初始化时，父类的构造函数也会运行，那是子类的构造函数默认第一行有一条隐式语句super（）；
super（）：会访问父类中空参数的构造函数，而且子类中的所有的构造函数默认第一行都是super（）；
为什么子类一定要访问父类中的构造函数？
因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。
所以子类在对象初始化时，要先访问一下父类中的构造函数。如果要访问父类中指定的构造函数，可以通过手动定义super语句方式来指定。
注意：super语句一定定义在子类构造函数的第一行。
结论：子类的所有的构造函数默认都会访问父类中空参数的构造函数。因为子类每一个构造函数内的第一行都有一句隐式的语句super（）；
当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类的构造函数。当然，子类的构造函数第一行也可以手动指定this语句来访问父类的构造函数。

三、final关键字

final作为一个修饰符，可以修饰类、函数、变量

1，被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。

2,被final修饰的方法不能被复写。

3，被final修饰的变量是一个常量，只能复制一次，既可以修饰成员变量，又可以修饰局部变量。

当描述事物时，一些数据的出现时固定的那么这时为了增强阅读性，都给这些值起个名字。而这个值不需要改变，所以加上final修饰。（作为常量：常量的书写规范所 有字母都大写，如果由多个单词组成，单词通过下划线（_）连接）。

4,内部类定义在类中的局部位置上时，只能访问该局部被final修饰的变量。

四、模板方法设计模式

在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去，由该类的子类去完成。

五、抽象

抽象类的特点：

1，抽象方法一定在抽象类中。

2，抽象方法和抽象类都必须被abstract关键字修饰。

3，抽象类不可以用new创建对象，因为调用抽象方法没有意义。

4，抽象类中的方法要被使用，必须由子类复写所有的抽象方法后，建立子类的对象调用。如果子类值覆盖了部分抽象方法，那么该类还是一个抽象类。

/*
需求：开发一个系统，需要对员工进行建模，员工包含3个属性，姓名、工号、以及工资。
	  经理也是员工，除了具有员工的属性外，另外还有一个奖金属性。用继承的思想设计出员工类与经理类。
*/

//抽取共有描述并定义员工与经理的父类
abstract class Employee
{
	private String name;
	private String id;
	private double pay;
	Employee(String name,String id,double pay)
	{
		this.name = name;
		this.id = id;
		this.pay = pay;
	}
	//抽象工作内容
	public abstract void work();
}
//定义员工类继承父类Employee
class Pro extends Employee
{
	pro(String name,String id,double pay)
	{
		super(name,id,pay);
	}
	//重写员工的工作内容
	public void work()
	{
		System.out.println("Pro Work");
	}
}
//定义经理类继承父类Employee
class Manager extends Employee
{
	private int bonus;
	Manager(String name,String id,double pay,int bonus)
	{
		super(name,id,pay);
		this.bonus = bonus;
	}
	//重写经理的工作内容
	public void work()
	{
		System.out.println("Manager Work");
	}
}

六、接口

初期理解，可以认为是一个特殊的抽象类当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。

interface 用于定义接口。
接口定义时，格式特点：

1，接口中常见定义：常量，抽象方法。

2，接口中的成员都有固定的修饰符。

常量：public static final

方法：public abstract

3，接口中的成员都是public的。

接口是不可以创建对象的，因为有抽象方法。需要被子类实现，子类对接口的抽象方法全部覆盖后，子类才可以实例化。否则子类时一个抽象类。

接口可以被类多实现，也是对多继承不支持的转换形式，Java支持多实现。

接口的特点：

1，接口是对外暴露的原则。

2，接口是程序的功能扩展。

3，接口可以用来多实现。

4，类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。

5，接口与接口之间可以有继承关系。

七、多态

可以理解为事物存在的多种体现形态。

1，多态的体现

父类的引用指向了自己的子类对象。

父类的引用也可以接收自己子类的对象。

2，多态的前提

必须是类与类之间有关系。要么继承，要么实现。

通常还有一个前提，存在覆盖。

3，多态的好处

多态的出现大大提高了程序的扩展性。

4，多态的弊端

虽然提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5，多态的应用

6，多态出现在代码中的特点

在多态成员函数的特点：

在编译时期：参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过，如果没有，编译失败。

在运行时期：参阅对象所属的类中是否有调用的方法。

简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。
在多态中，成员变量的特点：

无论编译和运行，都参考左边（引用型变量所属）。

在多态中，静态成员函数的特点：

无论编译还是运行，都参考左边（引用型变量所属的类）。

多态示例：

/*
需求：电脑运行实例
*/
//定义PCI接口
interface PCI
{
	public void open();
	public void close();
}
//定义主板类
class MainBoard
{
	public void run()
	{
		System.out.println("mainboard run");
	}
	public void usePCI(PCI p)
	{
		if(p != null)
		{
			p.open();
			p.close();
		}
	}
}

//定义网卡类实现PCI接口
class NetCard implements PCI
{
	public void open()
	{
		System.out.println("netcard run");
	}
	public void close()
	{
		System.out.println("netcard close");
	}
}

//定义声卡类实现PCI接口
class SoundCard implements PCI
{
	public void open()
	{
		System.out.println("SoundCard run");
	}
	public void close()
	{
		System.out.println("SoundCard close");
	}
}

class Computer
{
	public static void main(String[] args)
	{
		MainBoard mb = new MainBoard();
		mb.run();
		mb.usePCI(new NetCard());	//调用网卡
		mb.usePCI(new SoundCard()); //调用声卡
	}
}