黑马程序员---------Java基础-面向对象、设计模式

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

                                                                           面向对象

面向对象：相对于面向过程而言。是一种思想，强调的是功能的对象。
理解面向对象：
如请人修冰箱，我只面向冰箱的人，不面对修冰箱的过程,只看中修好冰箱的结果。
面向对象的本质：以类的方式组织代码，以对象的方式组织数据。
面向对象中类和对象：
象：是具体的事物，我们叫做object，instance实例，以后我们说某个类的对象，某个类的实例，是一样的意思
类：是对对象的抽象，我们叫做class，是对现实生活中事物的描述。

类和对象的关系：特殊到一般，具体到抽象。
类可以看成一类对象的模板，对象可以看成该类的一个具体实例。
类是用于描述同一类型的对象的一个抽象的概念，类中定义了这一类对象所应具有的静态和动态属性。
对象时JAVA程序的核心，在JAVA程序中“万物皆对象”。
JDK中提供了很多类供编程人员使用，编程人员也可定义自己的类。


定义类 ：
 class 类名(首字母大写){
  //属性
private 数据类型 属性名；
  //构造方法

}

例 :
Car c=new Car();
    c.color;

在堆内存中产生一个实体 ，通过new操作符来完成。
 
例如：
现实生活中的对象：张三 李四。
想要描述：提取对象中共性内容。对具体的抽象。
描述时：这些对象的共性有：姓名，年龄，性别，学习java功能。

映射到java中，描述就是class定义的类。
具体对象就是对应java在堆内存中用new建立实体。

类就是：对现实生活中事物的描述。
对象：就是这类事物，实实在在存在个体。



其中面向对象的三大特性：封装，继承，多态。

一 封装
概念:是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：将变化隔离；便于使用；提高重用性；安全性。
封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。
 
二 继承 
继承出现后，从三个方面理解它的些特点：
1.变量
    当子父类中定义了相同的名称的成员变量，
    子要使用父类中的同名变量时，需要使用关键字super来区分。
    一般不会出现这种情况，因为父类中有了，子类不需要定义。
    而且父类定义时，一般变量都私有化。

2.函数
    子类可以直接访问父类中非私有的成员函数。
    特殊情况：当子类中定义了与父类一模一样的方法时，会发生覆盖操作。大多指的是非静态方法。
             最终会运行子类的方法，父类相当于被覆盖了。
             函数的另一个特性：覆盖（重写，复写）。
             什么时候用啊？
             当父类的功能要被修改时，不建议修改源码。因为是灾难。
             只要通过一个类继承原有类，定义一个新的升级后的功能即可。
             但是功能是相同的，只是实现方法改变。这是子类可以沿袭父类中的功能定义，
             并重写功能内容。这就是覆盖。

             覆盖很爽，但是有注意事项：
                1，子类覆盖父类时，必须权限要大于等于父类权限。
                2，静态不能覆盖非静态。
            
3.构造函数
            构造函数可以本类进行对象初始化，也可以给子类对象进行初始化。
            子类对象初始化过程：
            子类中的所有构造方法都会访问父类中空参数的构造函数，
            因为每一个构造函数的第一行，都有一句隐式的super语句。
            为什么要有这条语句？
            因为子类会获取到父类中的数据，必须要先明确父类对数据的初始化过程。

            当父类中没有空参数构造函数时，子类构造函数必须通过super句来明确要访问的父类中指定的构造函数。

            当时子类构造函数也可以通过this语句访问本类中的构造函数。
            但是子类中肯定，至少有一个构造函数会访问父类。

class  jicheng
{
	public static void main(String[] args) 
	{
		Zi z = new zi();
        z.setNum(4);

	}
}
class Fu
{
	private int num = 9;
	public void show1(){}
	public void setNum(int num)
	{
		this.num  = num;
	}
	Fu(){}
}

class Zi extends Fu
{
	//int num = 4;

	void show()
	{
		int num = 7;
		System.out.println(super.num);
	}
 }

注意：
子类中所有的构造函数都会默认访问父类中的空参数的构造函数，因为每一个子类构造内第一行都有默认的语句super(); 
如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super语句指定要访问的父类中的构造函数。
如果子类构造函数中用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数。


Java语言中：java只支持单继承，不支持多继承。

因为多继承容易带来安全隐患:当多个父类中定义了相同功能，
当功能内容不同时，子类对象不确定要运行哪一个。
但是java保留这种机制。并用另一种体现形式来完成表示多实现。


java支持多层继承，也就是一个继承体系

如何使用一个继承体系中的功能

要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能。
通过了解共性功能，就可以知道该体系的基本功能。
那么这个体系已经可以基本使用了。
那么在具体调用时，要创建最子类的对象，为什么呢
一是因为有可能父类不能创建对象，
二是创建子类对象可以使用更多的功能


三 多态
多 态：函数本身就具备多态性，某一种事物有不同的具体的体现。
体现：父类引用或者接口的引用指向了自己的子类对象。
多态的好处：提高了程序的扩展性。
多态的弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)
多态的前提：
1、必须要有关系，比如继承、或者实现。
2、通常会有覆盖操作。 

                                                                                       单例设计模式

解决的问题：保证一个类在内存中的对象唯一性。
比如：多程序读取一个配置文件时，建议配置文件封装成对象。会方便操作其中数据，又要保证多个程序读到的是同一个配置文件对象，就需要该配置文件对象在内存中是唯一的。
     Runtime()方法就是单例设计模式进行设计的。
       如何保证对象唯一性呢？

思想：
1，不让其他程序创建该类对象。
2，在本类中创建一个本类对象。
3，对外提供方法，让其他程序获取这个对象。
步骤：
1，因为创建对象都需要构造函数初始化，只要将本类中的构造函数私有化，其他程序就无法再创建该类对象；
2，就在类中创建一个本类的对象；
3，定义一个方法，返回该对象，让其他程序可以通过方法就得到本类对象。（作用：可控）
代码体现：
1，私有化构造函数；
2，创建私有并静态的本类对象；
3，定义公有并静态的方法，返回该对象。



1、饿汉式
我们把先初始化对象。
Single类一进内存，就已经创建好了对象。

class Single
{
	private static Single s = new Single();
	private Single(){}
	public static Single getInstance()
	{
		return s;
	}
}

2、懒汉式
对象是方法被调用时，才初始化，也叫做对象的延时加载。

/Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。

class Single
{
	private static Single s = null;
	private Single(){}
	public static Single getInstance()
	{
		if(s==null)
		{
			synchronized(Single.class)
			{				
				if(s==null)
					s = new Single();
			}
		}
		return s;
	}
}

package www.itheima.com;
class Car
	{
		//描述颜色
		String color = "黑色";
		//描述轮胎数
		int num = 8;

		//运行行为
		void run()
		{

			System.out.println(color+"…………"+num);
		}
		
	}

public class itheima {
	
		public static void main(String[] args) 
		{
			
			
			//生产汽车。在java中通过new操作符来完成。
			//其实就是在堆内存产生一个实体。
			//Car c = new Car();//c就是一个类类型变量。记住：类类型变量指向对象。


//			Car c = new Car();
//			c.num = 5;
			//匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。
			//如果对一个对象进行多个成员调用，必须给这个对象起个名字。
			//匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。


			Car q = new Car();
			show(q);

			//show(new Car());
		}

		//需求：汽车修配厂。对汽车进行改装，将来的车够改成白车，6个轮胎。
		
		 
		public static void show(Car c)
		{
			c.num = 6;
			c.color = "white";
			c.run();
		}
	}