4、面向对象

面向对象

     特点：
1，面向对象就是一种常见的思想。符合人们的思考习惯。
2，面向对象的出现，将复杂的问题简单化。
3，面向对象的出现，让曾经在过程中的执行者，变成了对象中的指挥者。

     类与对象的关系

类：事物的描述

对象：该类事物的实例，通过new来创建。

    成员变量和局部变量的区别：
1，成员变量定义在类中，整个类中都可以访问。
局部变量定义在函数，语句，局部代码块中，只在所属的区域有效。
2，成员变量存在于堆内存的对象中。
局部变量存在于栈内存的方法中。
3，成员变量随着对象的创建而存在，随着对象的消失而消失。
局部变量随着所属区域的执行而存在，随着所属区域的结束而释放。
4，成员变量都有默认初始化值。
局部变量没有默认初始化值。 

    匿名对象：没有名字的对象。其实就是定义对象的简写格式。

当对象对方法仅进行一次调用的时候，就可以简化成匿名对象。匿名对象可以作为实际参数进行传递。

    封装思想

封装就是隐藏对象的属性和实现细节，仅对外提供公共访问方法。

好处：a、将变化隔离； b、便于使用； c、提高重用性； d、提高安全性。

封装原则：将不需要对外提供的内容全部隐藏起来，把属性都隐藏，提供公共方法对其访问。

构造函数：构建创造对象时调用的函数。

特点：函数名与类名相同；不用定义返回值类型；没有具体的返回值。
作用：可以给对象进行初始化。创建对象都必须要通过构造函数初始化。

一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。
如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。

一般函数和构造函数什么区别呢？

构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。
一般函数：对象创建后，需要函数功能时才调用。 

构造函数：对象创建时，会调用只调用一次。
一般函数：对象创建后，可以被调用多次。

什么时候定义构造函数呢？
在描述事物时，该事物一存在就具备的一些内容，这些内容都定义在构造函数中。
构造函数可以有多个，用于对不同的对象进行针对性的初始化.多个构造函数在类中是以重载的形式来体现的。

细节：
1，构造函数如果完成了set功能。set方法也需要。
2，一般函数不能直接调用构造函数。
3，构造函数如果前面加了void就变成了一般函数。
4，构造函数中是有return语句的。

    this关键字

当成员变量和局部变量重名，可以用关键字this来区分。
this : 代表对象。代表哪个对象呢？当前对象。 this就是所在函数所属对象的引用。 简单说：哪个对象调用了this所在的函数，this就代表哪个对象。
this也可以用于在构造函数中调用其他构造函数。
注意：只能定义在构造函数的第一行。因为初始化动作要先执行。

    static关键字

static的特点：
1，static是一个修饰符，用于修饰成员。
2，static修饰的成员被所有的对象所共享。
3，static优先于对象存在，因为static的成员随着类的加载就已经存在了。 
4，static修饰的成员多了一种调用方式，就可以直接被类名所调用 。 类名.静态成员 。
5，static修饰的数据是共享数据，对象中的存储的是特有数据。

成员变量和静态变量的区别？
1，两个变量的生命周期不同。
成员变量随着对象的创建而存在，随着对象的被回收而释放。
静态变量随着类的加载而存在，随着类的消失而消失。
2，调用方式不同。
成员变量只能被对象调用。
静态变量可以被对象调用，还可以被类名调用。
3，别名不同。
成员变量也称为实例变量。
静态变量称为类变量。 
4，数据存储位置不同。
成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据.
静态变量数据存储在方法区(共享数据区)的静态区，所以也叫对象的共享数据.

静态使用的注意事项：
1，静态方法只能访问静态成员。(非静态既可以访问静态，又可以访问非静态)
2，静态方法中不可以使用this或者super关键字。
3，主函数是静态的。

静态什么时候用？
1，静态变量。
当分析对象中所具备的成员变量的值都是相同的 。这时这个成员就可以被静态修饰。
只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。
如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。
2，静态函数。
函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中的特有数据。
简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。
如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，
但是非静态需要被对象调用，而仅创建对象调用非静态的没有访问特有数据的方法，该对象的创建是没有意义。

设计模式：对问题行之有效的解决方式。其实它是一种思想。

单例设计模式。
解决的问题：就是可以保证一个类在内存中的对象唯一性。
必须对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。

如何保证对象唯一性呢？
1，不允许其他程序用new创建该类对象。
2，在该类创建一个本类实例。
3，对外提供一个方法让其他程序可以获取该对象。

步骤：
1，私有化该类构造函数。
2，通过new在本类中创建一个本类对象。
3，定义一个公有的方法，将创建的对象返回。

<span style="font-size:14px;">//单例设计模式基本格式

//饿汉式
class Single
{
	private Single(){}

	private static Single s = new Single();

	public static Single getInstance()
	{
		return s;
	}
}

//懒汉式
class Single2
{
	private static Single2(){}

	private Single2 s = null;

	public static Single2 get()
	{
		if(s ==null)
			s = new Single2();
		return s;
	}
}</span>

继承：

继承的好处：
1，提高了代码的复用性。
2，让类与类之间产生了关系，给第三个特征多态提供了前提.

java中支持单继承。不直接支持多继承，但对C++中的多继承机制进行改良。

单继承：一个子类只能有一个直接父类。
多继承：一个子类可以有多个直接父类(java中不允许,进行改良)
不直接支持，因为多个父类中有相同成员，会产生调用不确定性。
在java中是通过"多实现"的方式来体现。

java支持多层(多重)继承。C继承B，B继承A。就会出现继承体系。

当要使用一个继承体系时，
1，查看该体系中的顶层类，了解该体系的基本功能。
2，创建体系中的最子类对象，完成功能的使用。 

当类与类之间存在所属关系的时候，就可以定义继承。

子父类中的成员变量

当本类的成员和局部变量同名用this区分。当子父类中的成员变量同名用super区分父类。
this和super的用法很相似。this:代表一个本类对象的引用。super：代表一个父类空间。

子父类成员函数

当子父类中出现成员函数一模一样的情况，会运行子类的函数。这种现象，称为覆盖操作。这是函数在子父类中的特性。

函数两个特性：
1，重载。同一个类中。overload
2，覆盖。子类中。覆盖也称为重写，覆写。override

覆盖注意事项：
1，子类方法覆盖父类方法时，子类权限必须要大于等于父类的权限。 
2，静态只能覆盖静态，或被静态覆盖。

当对一个类进行子类的扩展时，子类需要保留父类的功能声明，但是要定义子类中该功能的特有内容时，就使用覆盖操作完成.

子父类中的构造函数

在子类的构造函数中第一行有一个默认的隐式语句。 super();
子类的实例化过程：子类中所有的构造函数默认都会访问父类中的空参数的构造函数。

为什么子类实例化的时候要访问父类中的构造函数呢？
那是因为子类继承了父类，获取到了父类中内容(属性)，所以在使用父类内容之前，要先看父类是如何对自己的内容进行初始化的。
所以子类在构造对象时，必须访问父类中的构造函数。 为了完成这个必须的动作，就在子类的构造函数中加入了super()语句。

如果父类中没有定义空参数构造函数，那么子类的构造函数必须用super明确要调用父类中哪个构造函数。同时子类构造函数中如果使用this调用了本类构造函数时，那么super就没有了，因为super和this都只能定义第一行。所以只能有一个。但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数。

注意：supre语句必须要定义在子类构造函数的第一行。因为父类的初始化动作要先完成。

一个对象实例化过程：
如：Person p = new Person();
1，JVM会读取指定的路径下的Person.class文件，并加载进内存，
并会先加载Person的父类(如果有直接的父类的情况下).
2，在堆内存中的开辟空间，分配地址。
3，并在对象空间中，对对象中的属性进行默认初始化。
4，调用对应的构造函数进行初始化。
5，在构造函数中，第一行会先到调用父类中构造函数进行初始化。
6，父类初始化完毕后，在对子类的属性进行显示初始化。
7，在进行子类构造函数的特定初始化。
8，初始化完毕后，将地址值赋值给引用变量.

final关键字：
1，final是一个修饰符，可以修饰类，方法，变量。
2，final修饰的类不可以被继承。
3，final修饰的方法不可以被覆盖。
4，final修饰的变量是一个常量，只能赋值一次。
为什么要用final修饰变量。其实在程序如果一个数据是固定的，那么直接使用这个数据就可以了，但是这样阅读性差，所以它给该数据起个名称。而且这个变量名称的值不能变化，所以加上final固定。写法规范：常量所有字母大写，多个单词，中间用_连接。

抽象类（abstract）：
抽象：笼统，模糊，看不懂！不具体。

特点：
1，方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰。
抽象方法必须定义在抽象类中。该类必须也被abstract修饰。
2，抽象类不可以被实例化。为什么？因为调用抽象方法没意义。
3，抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化。
否则，这个子类还是抽象类。

1，抽象类中有构造函数吗？
有，用于给子类对象进行初始化。
2，抽象类可以不定义抽象方法吗？
可以的。 但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。
通常这个类中的方法有方法体，但是却没有内容。如下 ：

	abstract class Demo
	{
		void show1()
		{}
		void show2()
		{}
	}

3，抽象关键字不可以和那些关键字共存?
private 不行
static 不行
final 不行
4，抽象类和一般类的异同点。
相同点：
抽象类和一般类都是用来描述事物的，都在内部定了成员。
不同：
1，一般类有足够的信息描述事物。
  抽象类描述事物的信息有可能不足。
2，一般类中不能定义抽象方法，只能定非抽象方法。
  抽象类中可定义抽象方法，同时也可以定义非抽象方法。
3，一般类可以被实例化。
  抽象类不可以被实例化。
5，抽象类一定 是个父类吗？

是的。因为需要子类覆盖其方法后才可以对子类实例化。 

抽象类练习

/*
	雇员示例：
	需求：公司中程序员有姓名，工号，薪水，工作内容。
	项目经理除了有姓名，工号，薪水，还有奖金，工作内容。
	对给出需求进行数据建模。
*/
//描述雇员
abstract class Employee
{
	private String name;
	private int id;
	private double play;
	Employee(String name, int id, double play)
	{
		this.name = name;
		this.id = id;
		this.play = play;
	}
	public abstract void work();
}

//描述程序员
class Programmer extends Employee
{
	Programmer(String name, int id, double play)
	{
		super(String name, int id, double play);
	}
	public void work()
	{
		System.out.print("code....");
	}
}

//描述经理
class Manager extends Employee
{
	private int bonus;
	Manager(String name, int id, double play, int bonus)
	{
		super(String name, int id, double play);
		this.bonus = bonus;
	}
	public void work()
	{
		System.out.print("manage");
	}
}

接口（interface）

当一个抽象类中的所有方法都是抽象方法时，这时可以用另一个表现形式来定义和表示，即：接口。

定义接口使用的关键字不是class，是interface.

对于接口当中常见的成员：而且这些成员都有固定的修饰符。
1，全局常量: public  static final 
2，抽象方法。public abstract 
由此得出结论，接口中的成员都是公共的权限.

类与类之间是继承（extends）关系，类与接口之间是实现（implements）关系。

在java中不直接支持多继承，因为会出现调用的不确定性。所以java将多继承机制进行改良，在java中变成了多实现。

一个类在继承另一个类的同时，还可以实现多个接口。接口可以多继承，接口的出现避免了单继承的局限性。

接口的特点：

1、接口是对外暴露的规则。

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

3、接口的出现降低耦合性。

4、接口可以用来多实现。

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

6、接口与接口之间有继承关系。

抽象类和接口的异同点：
相同点：
都是不断向上抽取而来的。
不同点：
1，抽象类需要被继承，而且只能单继承。
  接口需要被实现，而且可以多实现。 
2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
  接口中只能定义抽象方法，必须由子类去实现。 
3，抽象类的继承，是is a关系，在定义该体系的基本共性内容。
  接口的实现是 like a 关系，在定义体系额外功能。