第二十七节：Java基础面向对象-静态，单例模式，继承详情知识点

忘是亡心i 2021-09-16 02:38 264阅读 0赞

![标题图][1240]

## 前言 ##

`Java`基础面向对象-静态，单例模式，继承详情知识点。`静态-static`关键字，`static`变量，静态代码块，代码块（不加静态），对象创建过程，单例模式，继承。

## 静态-static关键字 ##

// 定义类
    class Person {
     // 定义name,age属性
     private String name;
     private int age;
     // 定义有参数的构造方法
    Person(String name, int age){
     this.name = name;
     this.age = age;
     }
     // 定义方法
     public void speak(){
      System.out.println("name="+this.name+",age="+this.age);
     }
    }
     // 定义方法
    public void sleep(){
     System.out.println("睡觉");
     }
    }
    
    class PersonDemo{
     public static void main(String[] args){
      // 实例化对象
      Person p = new Person("dashucoding",12);
      // 调用功能
      p.speak();
      p.sleep();
     }
    }

在以上的代码中，我们会遇到这种情况，创建了一个对象，但是调用功能时，没有调用到对象中的数据，那么为啥还要调用呢？创建对象不就是为了封装数据的吗？

对象的创建为了产生实例，进行实例化对象进行调用，那么如果调用功能没有调用到对象中的数据，那么如果实例化很多对象时，不是浪费了堆内存中的空间了吗？这个问题值得我们深入研究。

## 问题解决 ##

创建对象就会浪费内存，那就加入`static`使用，这个是修饰符，为静态，被`static`修饰的为静态方法，可以直接被类名调用，当然也是可以被对象调用的。

// 定义方法
    public static void sleep(){
     System.out.println("睡觉");
     }
    }
    
    class PersonDemo{
     public static void main(String[] args){
      // 类的调用
     Person.sleep();
     }
    }

`static`修饰成员变量，**即为静态成员变量；修饰方法，为静态方法，修饰类，为静态类。**静态方法只能访问静态变量，不能访问非静态的。

// 定义方法，给添加个static
     public static void speak(){
      System.out.println("name="+this.name+",age="+this.age);
     }
    }
    // 结果报错
    错误：无法从静态上下文中引用非静态 变量

`static`解决了不用创建对象的问题，将方法改为静态，可让功能不需要访问类中定义的成员变量，就不用创建对象来浪费空间了。所以在`Java`中静态的添加就是为了解决这些问题。

## 静态方法是注意事项 ##

在静态方法中随着类的加载而加载，随着类的消失而消失；我们可知静态方法不能访问非静态的，可被类名直接调用，而且在静态方法中不能出现`this`，`super`的关键字。

我们如何去记住呢？`this,super`关键字为啥呢？

因为静态先存在内存中，此时对象有可能不存在，所以证名了，静态方法被类名直接调用，如果对象不存在；`this`和`super`关键字也一样，没有对象，哪来的`this，super`啊！

## public static void main ##

class Person{
     public static void main(String[] args)
     {
      System.out.println("hello");
      new Person.run();
      }
    }
    void run(){
     Sytem.out.println("run); }

在`static`修饰中，不需要对象，直接用类名就可以访问函数。在静态方法中可以调用非静态方法，一创建对象，而调用类名。

## static变量 ##

private static double pi = 3.14;

用静态修饰变量的值，每个对象需要用时，就可改为静态。

> 变量：静态变量，成员变量，局部变量

<table> 
 <thead> 
  <tr> 
   <th>静态变量</th> 
   <th>成员变量</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>静态变量属于类</td> 
   <td>成员变量属于对象</td> 
  </tr> 
  <tr> 
   <td>静态变量，类变量</td> 
   <td>成员变量，实例变量</td> 
  </tr> 
  <tr> 
   <td>可对象或类调用</td> 
   <td>对象调用</td> 
  </tr> 
  <tr> 
   <td>存储在方法区中</td> 
   <td>存储在堆内存中</td> 
  </tr> 
 </tbody> 
</table>

## 内存 ##

内存：方法区，栈，堆。

## 静态代码块 ##

class Demo{
     // 静态变量，先加载静态变量，默认初始化，显示初始化
     static int x = 3;
     // 静态代码块，静态变量显示初始化后执行
     static
     {
      System.out.println("类加载的静态代码块"+x);
     }
     // 静态方法
     static void show()
     {
      System.out.println("show");
     }
    }
    
    class StaticDemo{
     public static void main(String[] args){
      Demo.show();
      Demo.show();
     }
    }
    
    // 结果
    类加载的静态代码块3
    show
    show

静态代码块是随着类的加载而加载，只加载一次，给类进行初始化的作用。

## 代码块（不加静态） ##

class Demo{
     int x = 3;
     {
      System.out.println("run"+x);
     }
     Demo(){
      System.out.println("demo run");
     }
     Demo(int x){
      System.out.println("demo run int "+x);
     }
    }
    
    class NoDemo{
     public static void main(String[] args){
      new Demo();
      new Demo(4);
     }
    }

// 称为构造代码块
    {
      ...
    }

在构造代码块中，只要创建对象就会被调用，构造代码块为所有对象进行初始化，构造函数只针对对应的对象进行初始化。当调用对象时，构造代码块都会被调用。

{
     int x = 5;
     System.out.println("局部代码块"+x);
    }

对于局部代码块可以控制局部变量，当代码块调用完后，局部变量就被释放。

## 对象创建过程 ##

class Demo{
     // 定义静态变量
     static int x=2;
     // 定义变量
     int y =3;
     // 静态代码块
     static {
      System.out.println("static code"+x);
     }
     // 构造代码块
     {
      System.out.println("code"+y);
      }
     // 构造函数
      Demo(){
       System.out.println("demo"+y);
      }
    }
    class CreateDemo{
     public static void mian(String[] args){
       // 实例对象
       Demo demo = new Demo();
     }
    }

调用对象时，先显示静态的代码块，在显示构造的代码块，接着显示构造函数内的代码，按照顺序打印。静态代码块执行，仅执行一次，不管调用多少次对象，都是一次。

--------------------

## 单例模式 ##

**什么是设计模式，这是软件工程师为了解决某一问题提出的解决想法，设计模式共有23种，也可自己多想出来几种，学习其中一种单例模式。**

**单例模式：**多个程序要使用同一个配置文件，实现数据共享等，就需要将数据封装到一个对象中，然后进行操作。

单例设计模式就是在某一个类中，在整个应用中，有且只有一个实例（对象），即是一个类中只有一个对象实例。

class Singleton{
     // 对象
     static Singleton s = new  Singleton();
      // 私有化构造器
     private Singleton(){}
     // 返回该对象
     static Singleton getInstance(){
      return s; 
     }
    }

**步骤：**  
1): 私有化构造器；  
2): 自身事先提供好一个对象`（private static final）`；  
3): 向外暴露一个公共的静态方法,用于返回该对象。

饿汉式，一上来就吃
    class Single{
     private static final Single s = new Single(0;
     private Single(){}
     public static Single getInstance(){
      return s;
     }
    }

// 懒汉式，延迟加载方式
    class Single2{
     private static Single2 s2 = null;
     private Single2(){}
     public static Single2 getInstance(){
      if(s2==null){
        s2 = new Single2();
       }else{
        return s2;
       }
     }
    }

实例：

class Man{
     private String name;
     Man(String name){
      this.name = name;
     }
     public void setName(String name){
       this.name = name;
     }
     public String getName(){
      return this.name;
     }
     public void fly(){
      System.out.println(this.name+"fly");
     }
    }
    class Test{
     public static void main(String[] args){
       // 唯一
       Man man = new Man("dashu");
       man.fly();
      }
    }

个类中只有一个对象实例

class Man{
     private String name;
     // 单例模式
     private static Man man = new Man("dashu");
     private Man(String name){
      this.name = name;
     }
     public static Man getInstance(){
      return man;
     }
     // 模式
     public void setName(String name){
       this.name = name;
     }
     public String getName(){
      return this.name;
     }
     public void fly(){
      System.out.println(this.name+"fly");
     }
    }
    class Test{
     public static void main(String[] args){
       // 唯一
       Man man = new Man("dashu");
       man.fly();
      }
    }
    // 模式
    Man man1 = Man.getInstance();
    Man man2 = Man.getInstance();
    man1.setName("dashucoding");
    man2.fly();

--------------------

## 继承 ##

继承提高了代码的复用性，给类和类提供了关系。在`Java`中允许单继承，不能多继承，单继承，一个子类只能有一个父类。但`Java中`支持多重继承。

class Student{ 
     String name;
     int age;
     void study(){
      System.out.println("study");
     }
    }

class Worker{ 
     String name;
     int age;
     void work(){
      System.out.println("work");
     }
    }

继承案例：

class Person{ 
     String name;
     int age;
    }
    
    class Student extends Person{ 
     void study(){
      System.out.println("study");
     }
    }
    class Worker extends Person{ 
     void work(){
      System.out.println("work");
     }
    }

多重继承

class A{ }
    cass B extends A{}
    class C extends B{ }

## 结语 ##

*  本文主要讲解 **Java基础面向对象-静态，单例模式，继承详情知识点**
 *  下面我将继续对`Java`、 `Android`中的其他知识 深入讲解 ，有兴趣可以继续关注
 *  小礼物走一走 or 点赞

![送❤][1240 1]

[1240]: /images/20210724/8c5827a4f4204c92af3079bed0448a23.png
[1240 1]: /images/20210724/cdb95662248042c594a072a661fd1dea.png