一、static静态关键字
1.static的定义
- static修饰成员变量和成员方法
- 在内存中只存储一份,可以被共享、修改
2.static修饰成员变量的用法
- 有static修饰,属于类,加载一次,可以被共享访问
- 访问特点:
类名.静态成员变量(推荐)
对象.静态成员变量(不推荐)
3.static修饰成员变量的内存原理
3.1成员变量分类
- 静态成员变量:有static修饰,与类一起加载、属于类
- 实例成员变量:没有static修饰,与实例有关
3.2
public class User {
//静态成员变量,有static修饰,属于类,加载一次,可以被共享访问
public static int onlineNumber=161;
private String name;
private int age;
public static void main(String[] args) {
//1.类名.静态成员变量
System.out.println(User.onlineNumber);//161
System.out.println(onlineNumber);//同一个类中访问静态成员变量可以省略类名//161
User.onlineNumber++;//162
// System.out.println(name);//报错
//2.创建用户对象:对象.实例成员变量
User u1=new User();
u1.name="孙悟空";
u1.age=35;
System.out.println(u1.name);//孙悟空
System.out.println(u1.age);//35
//对象名称.静态成员变量,不推荐
u1.onlineNumber++;//163
User u2=new User();
u2.name="猪八戒";
u2.age=29;
System.out.println(u2.name);//猪八戒
System.out.println(u2.age);//29
u2.onlineNumber++;
//对象名称.静态成员变量,不推荐
System.out.println(onlineNumber);//164
}
}
4.static修饰成员方法的基本用法
4.1成员方法的分类:
-
静态成员方法:(有static修饰、归属于类),建议用类名访问,也可以用对象访问
-
实例成员方法:(无static修饰、对属于对象),只能用对象触发访问
4.2使用场景:表示对象自己行为的,且方法中需要访问实例成员的,则方法必须声明成实例方法 -
表示对象自己行为的,且方法中需要访问实例成员的,则方法必须声明成实例方法
-
如果该方法是以执行一个共用功能为目的,则可以声明成静态方法
5.static修饰成员方法的内存原理
public class Student {
/**
* 实例成员变量,无static修饰,属于对象
*/
private String name;
/**
* 静态成员方法,有static修饰,归属于类,可以被共享访问用类名或者对象名都可以访问
*/
public static int getMax(int age1,int age2){
return age1>age2?age1:age2;
}
/**
* 实例成员方法:属于对象,整只能用户对象触发访问
*/
public void study(){
System.out.println(name+"在好好学习");
}
public static void main(String[] args) {
//1.类名.静态成员方法
//注意:同一个类中访问静态成员方法可以省略类名
System.out.println(Student.getMax(10, 3));
//study();//会报错
//2.对象.实例方法
Student s=new Student();
s.name="猪八戒";
s.study();
//3.对象.静态成员方法
System.out.println(s.getMax(20, 10));//不推荐
}
}
6.static的注意事项
- 静态方法只能访问静态的成员,不能直接访问实例成员,可通过创建对象间接访问实例成员
- 实例方法既可以访问静态成员,也可以访问实例成员
- 静态方法中不可以出现this关键字
//目标:理解static访问的相关语法,面试笔试题,方面日后理解程序
public class Test {
/**
* 静态成员
*/
public static int onlineNumber=10;
//1.静态方法只能访问静态成员,不能直接访问实例成员
public static void test2(){
System.out.println("===============test2=====================");
}
/**
* 实例成员
*/
private String name;
private void run(){
System.out.println(name+"跑的快");
}
//3.静态方法中不可以出现this关键字
public static void test3(){
// System.out.println(this.name);this代表当前对象,静态方法可以不用对象调用
}
//2.实例方法可以访问静态成员,也可以访问实例成员
public void go(){
System.out.println(onlineNumber);//实例方法可以访问静态成员,静态成员是共享的
System.out.println(name);//实例方法可以访问实例成员
run();//实例方法可以访问实例成员
test2();//实例方法可以访问静态成员
System.out.println(this.name);
}
public static void test(){
System.out.println(Test.onlineNumber);//Test.可省略
Test.test2();//Test.可省略;
Test t=new Test();
System.out.println(t.name);//不能直接访问,可以通过创建对象间接访问
// System.out.println(name);//报错,不能直接访问实例成员
//run();//报错,能直接访问成员方法,可通过创建对象间接访问
t.run();
}
public static void main(String[] args) {
}
}
二、static应用知识:工具类
1.定义
类中都有一些静态方法,每个方法都是以完成一个共用的功能为目的,这个类用来给系统开发人员共同使用
2.优点
- 调用方便,提高了代码的复用(一次编写,处处可用)
3.案例
/**
* 工具类
*/
public class ItheimaUtil {
/**
* 静态方法
*/
public static String createVerifyCode(int n){
//开发一个验证码
//1.定义一个变量,记住验证码
String code="";
//2.定义一个变量记住全部验证码字
String data="abcdefghigklmnopqrstuvwxyzABCDEFGHIGKLKMOPQRSTUVWXYZ0123456789";
//3.定义一个循环生成几个随机索引,去得到几个字符
Random r=new Random();
for(int i=0;i<n;i++){
//4.获取随机索引对应的字符,连接code
int index=r.nextInt(data.length());
code+=data.charAt(index);
}
System.out.println("验证码为:"+code);
return code;
}
}
public class Login {
public static void main(String[] args) {
System.out.println(ItheimaUtil.createVerifyCode(5));
}
}
public class Check {
public static void main(String[] args) {
System.out.println(ItheimaUtil.createVerifyCode(6));
}
}
4.工具类中的方法不用实例方法
- 实例方法需要创建对象调用
- 此时用对象只是为了调用方法,这样只会浪费内存
5.工具类定义时的其他要求
- 由于工具里面的都是静态方法,直接用类名即可访问,因此,工具类无需创建对象,建议将工具类的构造器进行私有
三、static应用知识:代码块
1.代码块概述
- 代码块是类的5大成分之一(成员变量、构造器、方法、代码块、内部类),定义在类中方法外
- 在java类下,使用{}括起来的代码称为代码块
2.代码块的分类
2.1静态代码块
- 格式:static{}
public class StaticDemo1{
public static String schoolName;
public static ArrayList<String> cards=new ArrayList<>();
/**
* 静态代码块:有static修饰,与类一起优先加载一次,自动触发执行
* 作用:可以用于初始化静态资源
*/
static {
System.out.println("-------静态代码块被触发执行了------------");
schoolName="成功";
cards.add("3");
cards.add("4");
}
public static void main(String[] args) {
//目标:理解静态代码块
System.out.println("-----------------main方法执行--------------");
System.out.println(schoolName);
System.out.println(cards);
}
}
- 特点:需要通过static关键字修饰,随着类的加载而加载,并且自动触发发,只执行一次
- 使用场景:在类加载的时候做一些静态数据初始化的操作,以便后续使用
public class StaticDemo1{
public static String schoolName;
public static ArrayList<String> cards=new ArrayList<>();
/**
* 静态代码块:有static修饰,与类一起优先加载一次,自动触发执行
* 作用:可以用于初始化静态资源
*/
static {
System.out.println("-------静态代码块被触发执行了------------");
schoolName="成功";
cards.add("3");
cards.add("4");
}
public static void main(String[] args) {
//目标:理解静态代码块
System.out.println("-----------------main方法执行--------------");
System.out.println(schoolName);
System.out.println(cards);
}
}
2.2构造代码块(了解、见得少)
- 格式:{}
- 特点:每次创建对象。调用构造器执行时,都会执行该代码块中的代码,并且在构造器执行前执行
- 使用场景:初始化实例资源
public class StaticDemo2 {
private String name;
StaticDemo2(){
System.out.println("-------------无参构造器被触发执行了-----------------");
}
/**
* 实例代码块,无static修饰,属于对象,每次构建对象时,都会触发一次执行
*/
{
name="张三";
System.out.println("------------构造代码块被触发执行了------------------");
}
public static void main(String[] args) {
//目标:理解构造代码块(实例代码块)
StaticDemo2 s1=new StaticDemo2();
System.out.println(s1.name);//张三
StaticDemo2 s2=new StaticDemo2();
System.out.println(s2.name);//张三
}
}
注:设计开发中并不会这样用
2.3静态代码块的应用案例
需求:在启动游戏房间的时候,应该准备好54张牌,后续才可以使用这些数据
/**
* 1.定义一个静态的集合,这样这个集合只能加载一个,因为当前房价只需要一副牌
*/
public class StaticTest3 {
public static ArrayList<String> cards=new ArrayList<>();
static{
//3.正式做牌,放到集合中去
//a.先定义一个数组存储全部点数(类型确定,个数确定用数组)
String[] sizes={"3","4","5","6","7","8","9","10","J","Q","k","A","2"};
//b.定义一个数组存储全部花色(个数确定、类型确定用数组)
String[] colors={"♥","♠","♦","♣"};
//c.遍历
for (int i = 0; i < sizes.length; i++) {
//size[i]
//d.遍历花色
for (int j = 0; j < colors.length; j++) {
//colors[j]
String card=sizes[i]+colors[j];
cards.add(card);
}
}
//e.单独加入大小王
cards.add("小王");
cards.add("大王");
}
public static void main(String[] args) {
//目标:模拟游戏启动前初始化54张牌数据
/**
* 2.在程序真正运行main方法前,把54张牌放进去,后续游戏可以直接使用
*/
System.out.println("新牌:"+cards);
}
}
四、static应用知识:单例设计模式
1.设计模式的定义
开发中经常遇到的一些问题,一个问题通常有n种解法,但其中肯定有一种解法是最优的,这个最优解法被人总结出来称为设计模式
2.单例模式
- 可以保证系统中,应用模式的这个类永远只有一个实例,即一个类只能创建一个对象
- 例如任务管理器,只需要一个就可以解决问题,节省空间
3.单例模式的实现方式有很多
- 饿汉单例模式
- 懒汉单例模式
-
-
4.饿汗单例设计模式
4.1在用类获取对象时,对象已经提前创建好了
4.2饿汗单例的实现步骤
- 定义一个类,将构造器私有
private SingleInstance(){
}
- 定义一个静态变量存储一个对象
public static SingleInstance instance=new SingleInstance();
/**
* 使用饿汗单例实现单例类
*/
public class SingleInstance {
/**
* 2.饿汗单例是在获取对象前,对象已经准备好了一个
* 这个对象只能是一个,所以定义静态成员变量
*/
public static SingleInstance instance=new SingleInstance();
/**
* 1.必须将构造器私有
*/
private SingleInstance(){
}
}
public class Test1 {
public static void main(String[] args) {
//目标:理解饿汗单例的设计步骤
SingleInstance s1=SingleInstance.instance;
SingleInstance s2=SingleInstance.instance;
System.out.println(s1==s1);//true
}
}
5.懒汉单例模式
5.1定义
在真正需要该对象的时候,才去创建一个对象(延迟加载对象)
5.2懒汉单例的设计步骤
- 定义一个类,将构造器私有
- 定义一个静态变量存储一个对象
private static SingleInstance2 instance;
注意:私有化,这样避免给别人造成麻烦
- 提供一个返回单例对象的方法
public static SingleInstance2 getInstance(){
if(instance==null){
//第一次来拿对象,此时需要创建对象
instance=new SingleInstance2();
}
return instance;
}
public class SingleInstance2 {
/**
* 2.定义一个静态的成员变量,负责存储单例对象,
* 静态成员变量只加载一次,只有一份
* 注意:私有化,这样避免给别人造成麻烦
*/
private static SingleInstance2 instance;
/**
* 3.提供一个方法,对外返回单例的对象
*/
public static SingleInstance2 getInstance(){
if(instance==null){
//第一次来拿对象,此时需要创建对象
instance=new SingleInstance2();
}
return instance;
}
/**
* 1.私有化构造器
*/
public SingleInstance2() {
}
}
public class Test2 {
public static void main(String[] args) {
//目标:掌握懒汉单例的设计,并理解其思想
SingleInstance2 s1=SingleInstance2.getInstance();
SingleInstance2 s2=SingleInstance2.getInstance();
System.out.println(s1==s2);
}
}