疯狂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基础面向对象-静态,单例模式,继承详情知识点