zoukankan      html  css  js  c++  java
  • 第二十七节:Java基础面向对象-静态,单例模式,继承详情知识点

    标题图

    前言

    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中静态的添加就是为了解决这些问题。

    静态方法是注意事项

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

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

    因为静态先存在内存中,此时对象有可能不存在,所以证名了,静态方法被类名直接调用,如果对象不存在;thissuper关键字也一样,没有对象,哪来的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;

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

    变量:静态变量,成员变量,局部变量

    静态变量 成员变量
    静态变量属于类 成员变量属于对象
    静态变量,类变量 成员变量,实例变量
    可对象或类调用 对象调用
    存储在方法区中 存储在堆内存中

    内存

    内存:方法区,栈,堆。

    静态代码块

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

    送❤

  • 相关阅读:
    多线程(一)--线程的运行
    多线程(二)--锁
    守护线程与用户线程
    SWD接口
    RS485,CAN
    tcp/ip协议
    开关电源与线性稳压电源
    与gps相比,北斗的三频信号有什么优势
    射频识别技术(RFID)
    wifi发射模块芯片各个管脚功能,蓝牙和wifi信号互相干扰,2.4GHZ无线技术
  • 原文地址:https://www.cnblogs.com/dashucoding/p/11932520.html
Copyright © 2011-2022 走看看