【JAVA】static、工具类、代码块、单例、继承

1 static修饰成员变量

  • static是静态的意思,可以修饰成员变量和成员方法
  • static修饰成员变量表示该成员变量只在内存中存储一份,可以被共享访问、修改
  • 静态成员变量(有static修饰,属于类,内存中只加载一次)常表示需要被共享的信息,可以被共享访问(信息需要共享,只需要一份的时候使用)

public class Student{
    //静态成员变量
    public static String name="ABC";
    //实例成员变量
    private int age;

}
//访问静态成员变量
//类名.静态成员变量(推荐)
String name = Student.name;
// 也可以通过对象.静态成员变量(不推荐)
Student stu = new Student();
String n1 = stu.name;
  • 实例成员变量(无static修饰,属于对象):常表示姓名name、年龄等属于每个对象的信息
//实例成员变量的引用
//对象名.实例成员变量
Student s = new Student();
s.age = 1;
  • 同一个类中,静态成员的访问可以省略类名
  • 两种成员变量各自在什么情况下定义
静态成员变量 表示在线人数等需要被共享的信息
实例成员变量 属于每个成员,且每个成员的该信息不同时,如姓名,年龄等

2 static修饰成员方法

  • 成员方法分类
静态成员方法 有static修饰,类和对象共享 建议用类名访问(推荐),也可以用对象访问(但不推荐)
实例成员方法 无static修饰,归属于对象 只能用对象触发访问
  • 表示对象自己的行为的,且方法中需要直接访问实例成员,则该方法必须声明成实例方法
  • 如果该方法时以执行一个通用功能为目的,或者需要方便访问,则可以声明为静态方法
  • 静态成员方法

public class Student {
    // 实例成员变量,无static修饰,属于对象
    private int age;
    private String name;

    // 静态成员方法
    // 有static修饰,归属于子类,可以被共享访问,用类名或对象名都可以访问
    public static int getMax(int age1, int age2){
        return age1 > age2 ? age1 : age2;
    }
}
public static void main(String[] args) {
        // 静态成员方法的访问:类名.静态成员方法
        System.out.println(Student.getMax(18, 23));
        // 也可以对象.静态成员方法访问(但不推荐)
        Student stu = new Student();
        System.out.println(stu.getMax(18, 23));
    }

  • 实例成员方法

public class Student {
    // 实例成员变量,无static修饰,属于对象
    private int age;
    private String name;

    // 实例方法,只能用对象触发访问
    public void study(){
        // 实例方法可以直接访问当前实例变量,因为实例方法也是属于对象
        System.out.println(name);
    }
}
public static void main(String[] args) {
        // 实例方法访问:对象.实例方法
        Student stu = new Student();
        stu.name = "ABC";
        stu.study();
    }

3 static其它知识点

  • 静态方法只能访问静态的成员,不能直接访问实例成员(因为静态成员属于类,都可以共享,实例成员属于对象,必须用对象触发)
  • 实例方法可以访问静态成员,也可以访问实例成员(静态成员可以共享,实例成员和实例方法都属于对象),也可出现this关键字(实例方法是对象调用的)
  • 静态方法中是不可以出现this关键字(因为this关键字代表当前对象,静态方法可能不是用对象调用)

4 static工具类

工具类:类中都是一些静态方法,每个方法都是以完成一个共用的功能为目的,这个类用来给系统开发人员共同使用。(同一个功能多处开发,会出现代码重复度过高)

好处:调用方便,提高代码复用(工具类会把这些重复的功能,抽象成静态的方法)

为什么工具类不用实例方法做?

  1. 实例方法需要创建对象调用
  2. 此时用对象只是为了调用方法,会浪费内存

由于工具类里面都是静态方法,直接用类名就可以访问,所以,工具类无需创建对象,建议将工具类的构造器进行私有

public static Util{
    //将构造器设置为私有
    private Util(){
    }
    // 静态方法
    public static String createVerifyCode(int n){
        return n
    }
}

访问工具类,无需创造对象 

public static void main(String[] args) {
        
        System.out.println(Util.createVerifyCode(6);
}

5 代码块

  • 代码块是类的五大成分之一(成员变量、构造器、方法、代码块、内部类),定义在类中方法外
  • 在java类下,使用放在类中单独{}括起来的代码称为代码块

代码块

格式 特点 作用
静态代码块 static{} 需要通过static关键字修饰,随着类的加载而加载,并且自动触发,只执行一次 在类加载的时候做一些静态数据初始化的操作,以便后续使用
构造代码块 {} 每次创建对象调用构造器执行时,都会执行该代码块中的代码,并且在构造器执行前执行 初始化实例资源

6 单例设计模式

设计模式:开发中经常遇到一些问题,一个问题通常有n种解法,但其中肯定有一种是最优解,这个最优解被人总结出来,成为设计模式

  • 设计模式共有20多种,对应20多种软件来发中会遇到的问题
  • 学设计模式需要明白这种模式用来解决什么问题?遇到这种问题该模式怎么写?和如何解决这个问题

单例模式:可以保证系统中应用这种模式的这个类永远只有一个实例,即一个类永远只能创建一个对象

  • 例如,任务管理器对象,只需要一个任务管理器就可以解决问题,这样可以节省内存空间
  • 饿汉单例:在类获取对象时,对象已经提前创建好(速度更快,内存有点浪费)
  • 懒汉单例:在真正需要该对象的时候,才会去创建一个对象(延迟加载对象)(更节省内存)

饿汉单例

设计步骤:

  • 定义一个类,把构造器私有
  • 定义一个静态变量(静态变量只加载一次)存储一个对象
public class SingleInstance {
    // 2 饿汉单例获取对象,对象已经提前准备好
    // 因为对象只能是一个,所以定义静态成员变量,因为静态成员变量只会加载一次
    public static SingleInstance ins = new SingleInstance();
    // 1 把构造器私有化
    private SingleInstance(){

    }
}
public static void main(String[] args) {
        SingleInstance si = SingleInstance.ins;
        SingleInstance si2 = SingleInstance.ins;
        System.out.println(si == si2);//true,两个拿的是同一个地址

    }

懒汉单例

设计步骤:

  • 定义一个类,把构造器私有
  • 定义一个静态变量存储一个对象
  • 提供一个返回单例对象的方法
public class SingleInstance {
    // 2 定义一个静态成员变量负责一个对象,只加载一次,内存只有一份
    // !!!!!!不能new,只能等到用的时候才能new
    //public static SingleInstance ins = new SingleInstance();
    // 不能用public,因为用的时候会出现null
    private static SingleInstance inst;
    // 3 提供一个方法,对外返回单例对象
    public static SingleInstance getInstance(){
        if (inst == null){
            inst = new SingleInstance();
        }
        return inst;
    }
    // 1 把构造器私有化
    private SingleInstance(){

    }
}
public static void main(String[] args) {
        SingleInstance si = SingleInstance.getInstance();
        SingleInstance si2 = SingleInstance.getInstance();
        System.out.println(si == si2);//true,两个拿的是同一个地址
    }

7 继承

java中提供一个关键字extends,用这个关键字,可以让一个类与另一个类建立起父子关系

// Student称为子类,People称为父类
public class Student extends People{}
  • 子类继承父类后,可以直接使用父类公共的属性和方法
  • 子类们相同的特征(共性属性、共性方法)放在父类中定义,子类独有的属性和行为应该定义在子类自己里面。
  • 好处:提高代码的复用性,减少代码冗余,增强类的功能扩展性
  • 子类可以继承父类的私有成员,但是不能直接访问
  • 子类可以访问父类的静态成员,只是共享,不算继承
  • 子类可以继承父类的属性和行为,但子类不能继承父类的构造器
  • 不支持多继承,可以多层继承
  • java中所有类,要么直接继承Object类,要么默认继承Object类,要么间接继承Object类,Object是祖宗类

继承后访问成员

子类方法访问成员方法、成员变量:就近原则,先子类局部范围找,然后在子类成员范围找,最后父类成员范围找,如果父类范围没有找到则报错

  • 如果子父类中,出现了重名的成员,会优先使用子类的,若一定要在子类中使用父类成员,可以通过super关键字
// 访问子类中局部的name
String na = name;
// 访问子类对象的name
String name = this.name;
// 访问父类name
String name1 = super.name;

方法重写

在继承体系中,子类出现了和父类中一模一样的方法声明,则称子类的这个方法是重写的方法

重写注解:@Override

  • 子类重写父类方法时,访问权限必须大于等于父类(缺省
  • 子类不能重写父类的静态方法,如果写了就会报错

继承后构造器特点

  • super调用父类构造器的作用:通过调用父类有参构造器来出的实话继承自父类的数据
  • 子类所有的构造器默认都会先访问父类中无参构造器,再执行自己
super();
  • super调用父类有参构造器作用:初始化继承子父类的数据
super(x,y);
  • 如果父类没有无参构造器,子类会报错,因为子类默认调用父类无参构造器

this、super使用总结

  • 子类通过this(...)去调用本类的其它构造器,被雷其它构造器会通过super去手动调用父类的构造器,最终还是会调用父类构造器
  • this(...)super(...)都只能放在构造器的第一行,所以二者不能共存在一个构造器中
关键字 访问成员变量 访问成员方法 访问构造方法
this访问本类成员 this.成员变量 this.成员方法(...) this(...)访问本类兄弟构造器
super访问父类成员 super.成员变量 super.成员方法(...) super(...)访问父类构造器

 this访问本类构造器

public student(String name){
        this(name, 18);
    }    
    public student(String name, String age){
        this.name = name;
        this.age = age;
    }
public static void main(String[] args) {
        student stu1 = new student("A", 12);
        // 这时候年龄就为18了
        student stu2 = new student("B");

    }

你可能感兴趣的:(java,开发语言)