黑马程序员——Jave面向对象二

------- android培训、java培训、期待与您交流！ ----------

1.封装
封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
封装的好处：
A.将变化隔离
B.便于使用
C.提高重用性
D.提高安全性
封装原则：
将不需要对外提供的内容都隐藏起来。
把属性都隐藏，提供公共方法对外访问。
使用private修饰符对成员变量，成员方法进行修饰，私有只是封装的
一种体现形式，不完全代表封装。
被private修饰的内容，只在自己的类中，才能被使用，出去了自己的
类中，不能再使用。

2.单例模式(Singleton)
单例对象（Singleton）是一种常用的设计模式。在Java应用中，
单例对象能保证在一个JVM中，该对象只有一个实例存在。
这样的模式有几个好处：
A.某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。
B.省去了new操作符，降低了系统内存的使用频率，减轻GC压力。
    C.有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，
 系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），
 所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程

首先我们写一个简单的单例类：
我们如果保证类在内存中只有一个对象呢?
A.为了控制该类对象的建立,不让其他的类创建该类的对象.
B.在本类中应该提供一个本类对象.
C.提供公共的方式供别人访问这个对象.


代码如何实现呢？
A.构造函数私有化，防止其他类创建该类对象
B.在本类中，通过new关键字创建一个对象
C.提供一个public方法，对外访问

单例设计模式 形式一（饿汉式）
class Student{
//构造函数私有化，防止其他类创建该类对象
private Student(){}
//在本类中，通过new关键字创建一个对象
//由于静态方法只能修饰静态变量，所以需要static修饰
//为了避免外界访问本类中的属性，通过private修饰
private static Student s = new student();

//为了方便外界访问，通过static修饰
public static Student getInstance(){
return s;
}
}

单例设计模式 形式二（懒汉式）
class Student {
//防止其他类 创建本类对象
private Student(){}
//在类中 创建一个本类对象
//private static Student stu = new Student();
//不想类文件 ，加载到内存中 立刻创建对象
//想 调用获取对象的方法的使用，再创建对象
private static Student stu = null;
//对外提供公共访问方法
public static Student getInstance() {
if (stu == null) {
stu = new Student();
}
return stu;
}
}

两种单例设计模式的区别？
第一种：对象随着类的加载而创建
第二种：需要使用的时候，再创造对象，以后使用的是同一个对象。
使用场合:
工作的时候： 第一种
面试的时候： 第二种
原因：第二种，会出现线程安全问题

3. 继承
我们在定义一个类的时候，不需要从头开始。可以在某些类的基础上，扩充自己的功能即可。
让我们的类和那个已经存在的类产生一个关系，我就能够具备别人的成员。这个关系：继承。

继承的好处：
A:提高代码的复用性。
B:让类与类之间产生了一个关系，是多态的前提。
继承的弊端：
破坏了耦合性。类之间的关系过强，会导致一个类的改动直接影响其他的类。

继承的特点：
A:Java中类只支持单继承。
B:可以多层继承。

什么时候考虑使用继承?
假设法：is a的关系。

方法重写：
一般是指在子类中出现了和父类一模一样的方法声明，方法体不一样。
注意：
A:父类的私有方法不能被重写。
B:子类重写后的方法的访问权限要大于等于父类方法的访问权限。
C:子类重写后的方法的返回值类型：
基本类型：一致。
引用类型：是父类本身或者父类的子类。
开发中，基本上不会出现注意里面的问题，因为开发中方法声明都是一模一样的。

4.多态
同一个对象，在不同时刻表现出现的不同状态。
举例：水(水，冰，水蒸气)
     狗(动物,狗)
从代码的角度来看：编译期状态和运行期状态不一致的现象。
Fu fu = new Fu();
Zi zi = new Zi();
Fu fu = new Zi();

前提：
A:有继承或者实现关系。
B:有方法的重写。
C:父类或者父接口的引用指向子类对象。

class Fu {
public int num = 10;

public void show() {
System.out.println("Fu"+num);
}
}

class Zi extends Fu {
public int num = 10;
public int num2 = 20;

public void show() {
System.out.println("Zi"+num);
System.out.println("Zi"+num2);
}

            public void method() {
System.out.println("method");
}
}

测试类：
class Test {
public static void main(String[] args) {
/*
Fu f = new Fu();
System.out.println(f.num);
f.show();

Zi zi = new Zi();
System.out.println(zi.num);
zi.show();
*/

//多态
Fu f = new Zi();
System.out.println(f.num);
//System.out.println(f.num2);

f.show();
//f.method();
}
}
多态中成员的特点：
成员变量：编译和运行都看左边。
成员方法：编译看左边，运行看右边。

5.抽象类
如果多个类中有相同的方法声明，而方法体不一样，我们就可以只抽取方法声明，定义到一个类中。
而一个方法如果没有方法体，也就是说该方法不是具体的，只能是一个抽象的，又因为一个类中有抽象
方法，该类必须定义为抽象类。
抽象类的特点：
A:抽象类和抽象方法都必须用abstract修饰。
B:抽象类被子类继承的时候：
要么子类全部重写抽象方法。
要么子类是一个抽象类。
C:抽象类不能被实例化。
为什么会有构造方法呢?
用于子类访问父类数据的初始化。
D:抽象类中的非抽象方法，可以被子类继承并使用。
 抽象类中的抽象方法，是要求子类必须做某些事情。

6.接口
抽象类中的方法都是抽象的时候，java就提供了一种更抽象的表现方式：接口。


接口的特点：
A:接口用interface修饰
B:接口被类实现的时候：
要么全部重写。
要么是抽象类。
C:接口不能被实例化。

7.抽象类和接口的区别
A:成员区别
抽象类：
成员变量：既可以是常量，也可是变量。
构造方法：有。
成员方法：既可以是抽象方法，也可是是非抽象方法。
接口：
成员变量：只能是常量。
 默认修饰符：public static final
成员方法：只能是抽象方法。
 默认修饰符：public abstract
B:类或者接口的关系区别?
类与类的关系：
继承关系，只能单继承，但是可以多层继承。
类与接口的关系：
实现关系，可以单实现，也可以多实现。
还可以在继承一个类的同时，实现多个接口。
接口与接口的关系：
继承关系，可以单继承，也可以多继承。
C:设计理念区别
抽象类被继承体现的是：is a的关系。它里面定义的是这个体系的共性功能。
接口被实现体现的是：like a的关系。它里面定义的是这个体系的扩展功能。