黑马程序员——Java要点笔记——面向对象（三）

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

day08 04-面向对象-单例设计模式-概述&体现
1、设计模式：来源与建筑行业。是一种对问题进行有效解决的方式。其实，它是一种思想。
2、单例设计模式（单个实例，单个对象，单块堆内存）
       解决的问题：就是可以保证一个类在内存中的对象唯一性。
3、用全静态也可以实现，为什么不用？答：若变量太多，生命周期又太长，浪费内存。
4、必须对于多了程序使用同一个配置信息对象时，就需要保证该对象的唯一性。一块堆内存，不断地更改栈内存指向。
5、如何保证对象的唯一性呢？
①不允许其他程序用new 来创建该对象。
②在类中创建一个本类实例。
③对外提供一个静态方法，让其他程序可以获取该对象。
6、步骤：
①私有化该类的构造函数。（私有）
②通过new，在本类中创建一个本类对象。（私有并静态）
③定义一个公有的方法，将创建的对象返回。（静态）
7、代码示例
class Single{
private Single(){

}
private static Single s=new Single();
public static Single getInstance(){
return s;
}
}
8、为什么s要是静态且私有的？
       Singless=Single.getInstance();
       Singless=Single.ss;
       第二种不可控，而上面有getInstance()方法，我可以在这里加权限。有了方法，就有了可控的可能。
day08 05-面向对象-单例设计模式-内存图解
1、代码示例
class Single{
private Single(){
}
private static Single s=new Single();
public static Single getInstance(){
return s;
}
}
public class TestDemo13 {
public static void main(String[] args) {
Single s1=Single.getInstance();//没有新new，就没有新开辟对内存空间，没有新对象出来
Single s2=Single.getInstance();//没有新new，就没有新开辟对内存空间，没有新对象出来
System.out.println(s1==s2);
}
}
运行结果：true







day08 06-面向对象-单例设计模式-懒汉式
1、饿汉式（类一加载，对象就已经存在了）
class Single{
private static Single s=new Single();
private Single(){};
public static Single getInstance(){
return s;
}
}
2、懒汉式（类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象）
class Single{
private static Single s=null;
private Single(){};
public static Single getInstance(){
if(s==null){//不加这个判断，每次调用getInstance方法时，都会new一个对象出来。而上次new的对象有指向，所以不会变垃圾。这样就不能保证是单例了。
s=new Single();
}
return s;
}
}
3、在真正开发时，饿汉式用的多。懒汉式存在安全隐患（多线程）。但是，面试时面的几乎都是懒汉式。
day08 07-面向对象-继承-概述
1、父类又被称为基类、超类。
2、继承的好处：
       ①提高了代码的复用性
       ②让类与类之间产生了关系，给第三个特征多态提供了依据
3、父类是怎么来的？是不断向上抽取而来的。
day08 08-面向对象-继承-Java中的单继承和多继承
1、java中支持单继承不直接支持多继承。但对C++中的多继承，进行了改良。
       单继承：一个子类只能有一个直接父类。
       多继承：一个子类可以有多个直接父类（java中不允许，进行了改良）
2、伪代码示例
class A{
void show(){
System.out.println("a");
}
}
class B{
void show(){
System.out.println("b");
}
}
class C extends A,B{
}
……
new C().show;
这个时候出问题了，此时是打印“a”还是“b”？这叫不确定性。两个父类中有相同的方法时，不知道该运行哪一个。
3、不直接支持多继承是因为多个父类中有相同成员，会产生调用的不确定性。在java中是通过多实现的方法来体现的。
4、java支持多重继承：



5、当要使用一个继承体系时：
①查看该体系的顶层类，了解该体系的基本功能。
②创建体系中的最子类对象（最靠谱），完成功能的使用。
day08 09-面向对象-继承-定义继承
1、特别注意：千万不要为了提高代码的复用性去写继承，有关系继承，没关系就不要继承。继承会把父类中的东西全部拿过来，父类中的东西是你全需要的时候，才去继承。
2、代码示例
class A{
void show1(){}
void show2(){}
}
class B extends A{
//void show1(){}
void show3(){}
}
    以上思路就是错误的。B本来没有show2()这个方法，你一继承，他多了个show2()，很危险。继承——是所有东西一股脑全拿过来。
3、什么时候定义继承呢？
       当类与类之间存在着从属关系的时候，就定义继承，xxx是yyy中的一种。
       xxx extends  yyy
       判断父类中的功能是不是该类中都存在。
day08 10-面向对象-继承-子类中成员变量的特点
1、在子类中，成员的特点体现：①成员变量②成员函数③构造函数
2、成员变量
代码示例：
class Fu{
int num=4;
}
class Zi extends Fu{
int num=5;
void show(){
System.out.println(num+"……"+num);
}
}
……Zi z=new Zi();
  z.show();
       运行结果：5……5
       由此可见，对于成员变量，子如果有就不找父。
3、那此时我如果是想操作父类中的这num，该怎么办？
       当本类的成员变量和局部变量同名时，通过this来区分（this调用的是成员变量）。
       当子父类中的成员变量同名时，通过super来区分（super调用的是父类成员）。
4、System.out.println(super.num+"……"+this.num); 

       运行结果：4……5
5、this与super有什么区别？
       this代表一个本类对象的引用。
       super代表一个父类空间（因为没有父类对象）
6、子类为何能直接获取父类中的内容？
       因为子类持有着super。当我子类没有时，通过super去父类中查找。若子父类中都有，通过super来区分。
7、代码示例
public class Demo09 {
public static void main(String[] args) {
Zi z=new Zi();
z.show();
}
}
class Fu{
int num=4;
void show(){
System.out.println(num+"……"+num);
}
}
class Zi extends Fu{
int num=5;
}
       运行结果：4……4
       其实System.out.println(num+"……"+num);完整应该是 System.out.println(this.num+"……"+this.num);
day08 11-面向对象-继承-子类中成员变量的内存图解
1、代码示例
public class Demo09 {
public static void main(String[] args) {
Zi z=new Zi();
z.show();
}
}
class Fu{
int num=4;
}
class Zi extends Fu{
int num=5;
void show(){
System.out.println(this.num+"……"+super.num);
}
}
运行结果：5……4









2、  注意：父类中的私有内容，子类不具备！
day08 12-面向对象-继承-子类中成员函数的特点-覆盖
1、代码示例
public class Demo09 {
public static void main(String[] args) {
Zi z=new Zi();
z.show1();
z.show2();
}
}
class Fu{
void show1(){
System.out.println("fu showrun");
}
}
class Zi extends Fu{
void show2(){
System.out.println("zi showrun");
}
}
运行结果：fu show run
zi show run



2、代码示例
public class Demo09 {
public static void main(String[] args) {
Zi z=new Zi();
z.show();
}
}
class Fu{
void show(){
System.out.println("fu showrun");
}
}
class Zi extends Fu{
void show(){
System.out.println("zi showrun");
}
}
运行结果：zi show run



3、成员函数
       当子父类中出现成员函数一模一样的情况，会运行子类的函数。这种现象，称为覆盖操作。这是成员函数在子父类中的特性。（注意：父类中的show方法还是存在的）
4、函数的两个特性：
       ①重载：同一个类中，overload
       ②覆盖：子类中，覆盖也称为重写、覆写。override。覆盖要求子类和父类中函数的声明完全一模一样！（返回值、函数名、参数列表）
5、覆盖的注意事项（重点）
①子类方法覆盖父类方法时，子类权限必须要大于等于父类的权限。



②静态只能覆盖静态，或被静态所覆盖





       原来人家静态的好好的，可以直接被类名调用。你一覆盖，改成非静态了，不能直接被类名调用了，这算什么意思？
③父类私有方法不能被子类方法覆盖



④覆盖要求子类和父类中函数的声明完全一模一样！（返回值、函数名、参数列表）



day08 13-面向对象-继承-子类中成员函数特点-覆盖的应用
1、什么时候使用覆盖？
       举例：手机的来电显示。



2、当对一个类进行子类的扩展时，子类需要保留父类的功能声明，但是要定义子类中该功能的特有内容时，就是用覆盖操作完成。
       以上例来说：你只要创建的是我的子类，就既能用这个call()，也能用这个show()。只是创建的这个新对象如果是iphone的话，那么它的show()就能显示（人名、号码、大头贴）。
3、方法覆盖时的代码复用



       静态前面省略的是类名，非静态前面省略的是this。全都是这样。
       本类中定义过的非静态前面省略的是this，子类继承父类中前面省略的是super。