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

最新推荐文章于 2025-01-05 16:17:53 发布

军师同学

最新推荐文章于 2025-01-05 16:17:53 发布

阅读量574

点赞数

CC 4.0 BY-SA版权

分类专栏： Java要点笔记

本文链接：https://blog.youkuaiyun.com/u013114489/article/details/46861889

Java要点笔记专栏收录该内容

18 篇文章

订阅专栏

------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