Java开发从入门到精通（九）：Java的面向对象OOP：成员变量、成员方法、类变量、类方法、代码块、单例设计模式，final关键字

置顶 HACKNOE

已于 2024-04-12 11:16:19 修改

阅读量1.1k

点赞数 25

分类专栏： Java开发从入门到精通文章标签： java 设计模式开发语言

于 2024-03-15 23:28:11 首次发布

本文链接：https://blog.csdn.net/qq_43422402/article/details/136752404

版权

Java开发从入门到精通专栏收录该内容

48 篇文章 2 订阅

订阅专栏

Java大数据开发和安全开发

（一)Java的变量和方法

（一)Java的变量和方法

1.1 成员变量

待补充

1.2 成员方法

待补充

1.3 static关键字

static关键字的概念：

			静态的意思，可以修饰成员变量、成员方法。

1.3.1 static修饰成员变量

成员变量按照有无static修饰，分为两种:

类变量
实例变量(对象的变量)
类变量:有static修饰，属于类，在计算机里只有一份，会被类的全部对象共享
实例变量(对象的变量): 无static修饰，属于每个对象的

public class Student {
    // 类变量
    static String name;
    // 实例变量(对象的变量)
    int age;

}

public class Test {
    public static void main(String[] args) {
        // 目标:掌握有无static修饰成员变量的用法，特点。
        // 1、类变量的用法。
        // 类名.类变量(推荐)
        Student.name ="袁华";

        // 对象.类变量(不推荐)
        Student s1 = new Student();
        s1.name ="马冬梅";  //会被类的全部对象共享

        Student s2 = new Student();
        s2.name="秋雅";    //会被类的全部对象共享

        System.out.println(s1.name);//  秋雅
        System.out.println(Student.name);// 秋雅

        //2、实例变量的用法:属于每个对象的变量
        // 对象.实例变量
        s1.age = 23;
        s2.age = 18;
        System.out.println(s1.age);//23
    }
}

成员变量的执行原理

在这里插入图片描述

1.3.1 static修饰成员变量的应用场景

类变量的应用场景

在开发中，如果某个数据只需要一份，且希望能够被共享(访问、修改)，则该数据可以定义成类变量来记住

案例导学：

系统启动后，要求用户类可以记住自己创建了多少个用户对象了

public class User {
    // 类变量
    public static int number;
    public User(){
        // User.number++;
        // 注意:在同一个类中，访问自己类的类变量，才可以省略类名不写。
        number++;
    }
}

public class Test2 {
    public static void main(String[] args) {
        // 目标:通过案例理解类变量的应用场景、
        User ul = new User();
        User u2 = new User();
        User u3 = new User();
        User u4 = new User();
        System.out.println(User.number);
    }
}

1.3.1 static修饰成员方法

成员方法的分类

类方法 :有static修饰的成员方法，属于类。（也叫静态方法）

在这里插入图片描述

实例方法 :无static修饰的成员方法，属于对象

在这里插入图片描述

public class Student {
    double score;// 类方法
    public static void printHelloWorld() {
        System.out.println("Hello World");
        System.out.println("Hello World");
    }

    //实例方法(对象的方法)
    public void printPass(){
        System.out.println("成绩:" +
                (score >=60 ?"及格":"不及格"));
    }
}

public class Test {
    public static void main(String[] args) {
        // 目标:掌握有无static修饰方法的用法。// 1、类方法的用法
        // 类名.类方法(推荐)
        Student.printHelloWorld();
        // 对象.类方法(不推荐)
        Student s= new Student();
        s.printHelloWorld();
        
        // 2、实例方法的用法// 对象.实例方法
        s.printPass();
        // Student.printPass();// 报错  不能使用类名访问实例方法
    }
}

成员方法的执行原理
在这里插入图片描述

搞懂main方法
main方法使用static修饰也就说明main方法是类方法，Test.class在运行时会直接执行Test.main方法，所以main可以直接运行不需要别人调用，String[] args 代表main方法可以传参的，怎么传呢？看下面

在这里插入图片描述
这里我们用txt写了一段循环的代码使用java编译来运行

java在编译执行的时候可以按照参数的类型直接传参，这是就是main方法的传参

1.3.1 static修饰成员方法的应用场景

类方法最常见的应用场景是做工具类

工具类是什么?

工具类中的方法都是一些类方法，每个方法都是用来完成一个功能的，工具类是给开发人员共同使用的。

使用类方法来设计工具类有啥好处?

提高了代码复用;调用方便，提高了开发效率

类方法应用场景案例

某系统登录页面需要四位数的验证码注册页面需要六位数的验证码

在这里插入图片描述
登录页面写一次生成验证码的代码注册页面再写一次代码重复率很高

所以使用工具类来简化代码

import java.util.Random;

public class GongJuLei {
    public static String CreateCode(int n){
        String code ="";
        String data = "abcdefghijklmnopqrstuVwXyZABCDEFGHIJKLMNOPORSTUVWXYZ0123456789";
        Random r =new Random();
        // 2、开始定义一个循环产生每位随机字符
        for(int i=0;i<n;i++){
            // 3、随机一个字符范围内的索引。
            int index = r.nextInt(data.length());
            // 4、根据索引去全部字符中提取该字符
            code += data.charAt(index);//code =code +字符
        }
        return code;
    }
}

public class Reg {
    public static void main(String[] args) {
        //注册页面
        GongJuLei.CreateCode(6);
    }
}

public class Reg {
    public static void main(String[] args) {
        //注册页面
        GongJuLei.CreateCode(6);
    }
}

在这里插入图片描述

为什么工具类中的方法要用类方法，而不用实例方法?

实例方法需要创建对象来调用，此时对象只是为了调用方法，对象占内存，这样会浪费内存。
类方法，直接用类名调用即可，调用方便，也能节省内存。

多学一招:

工具类没有创建对象的需求，建议将工具类的构造器进行私有
使用工具类无需再创建对象，直接用类名调用，为了不让别人创建对象可以私有化构造器，这样在实例化对象时调用不了无参构造器就会失败

    private GongJuLei(){
        
    }

1.3.1 static的注意事项

类方法中可以直接访问类的成员，不可以直接访问实例成员
实例方法中既可以直接访问类成员，也可以直接访问实例成员
实例方法中可以出现this关键字，类方法中不可以出现this关键字的
实例方法中可以直接访问当前类的私有成员

public class Student {
    static String schoolName;//类变量
    double score;//实例变量

    //1、类方法中可以直接访问类的成员，不可以直接访问实例成员
    public static void printHelloWorld() {
        // 注意:同一个类中，访问类成员，可以省略类名不写、
        Student.schoolName = "黑马";
        Student.printHelloWorld2();
        schoolName = "黑马";//可以省略类名不写、
        printHelloWorld2();//可以省略类名不写、
        //System.out.println(score);// 报错的 不可以直接访问实例成员
        //printPass();//报错的 不可以直接访问实例方法

        //System.out.println(this);报错的 不可以直接访问this
    }

    //类方法
    public static void printHelloWorld2() {

    }

    //2、实例方法中既可以直接访问类成员，也可以直接访问实例成员
    // 实例方法
    public void printPass(){
            schoolName ="黑马2";//访问类成员
            printHelloWorld2();//访问类方法

        System.out.println(this);  //可以直接访问this
    }
}

1.3.1 static的应用知识:代码块

代码块概述

代码块是类的5大成分之一(成员变量、构造器、方法、代码块、内部类)

代码块分为两种:

静态代码块

 格式:static{}
 特点:类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次
 作用:完成类的初始化，例如:对类变量的初始化赋值。

实例代码块

 格式:{}
 特点:每次创建对象时，执行实例代码块，并在构造器前执行。
 作用:和构造器一样，都是用来完成对象的初始化的，例如:对实例变量进行初始化赋值

静态代码块

public class Student {
	static int number =80;
	static String schoolName;// 静态代码块
	static {
		System.out.println("静态代码块执行了~~");
		schoolName =“黑马";// 初始化赋值
	}
	
	// 实例代码块
	{
		System.out.println("实例代码块执行了~~");
	}
	public student(){
		System.out.println("无参数构造器执行了~~")
	}
	public student(String name){
		System.out.println("有参数构造器执行了~~");
	}
}

public class Test {
	public static void main(string[] args){
	// 目标:认识两种代码块，了解他们的特点和基本作用。			
		System.out.println(student.number); //类加载时自动执行
		System.out.println(Student.number);
		System.out.println(Student.number);
		
		System.out.println(Student.schoolName);//
		
		System.out.println("---------------")
		Student sl =new Student();
		Student s2 =new Student(name:"张三");

实例代码块

每次创建对象时，执行实例代码块，并在构造器前执行构造器也是创建对象时执行

public class Student {
	static int number =80;
	static String schoolName;// 静态代码块

	// 实例代码块
	{
		System.out.println("实例代码块执行了~~");
		System.out.println("有人创建了对象:" + this);
	}
	public student(){
		System.out.println("无参数构造器执行了~~")
	}
	public student(String name){
		System.out.println("有参数构造器执行了~~");
	}
}

public class Test {
	public static void main(string[] args){
	// 目标:认识两种代码块，了解他们的特点和基本作用。			
		System.out.println("---------------")
		Student sl =new Student();   
		Student s2 =new Student(name:"张三");

实例代码块执行了~~
无参数构造器执行了~~
实例代码块执行了~~
有参数构造器执行了~~

1.3.1 static的应用知识:单例设计模式

什么是设计模式(Design pattern）

一个问题通常有n种解法，其中肯定有一种解法是最优的，这个最优的解法被人总结出来了，称之为设计模式

关于设计模式的学习，主要学什么?

在这里插入图片描述
单例设计模式

确保一个类只有一个对象。

写法

把类的构造器私有。
定义一个类变量记住类的一个对象。
定义一个类方法，返回对象。

public class A{
	// 2、定义一个类变量记住类的一个对象
	private static Aa= new A();
	//1、必须私有类的构造器
	private A(){
	}
	//3、定义一个类方法返回类的对象
	public static A getobject(){
		return a;
	}
}

public class Test1{
	public static void main(String[] args){
		// 目标:掌握单例设计模式的写法。
		A a1 = A.getobject();
		A a2 = A.getobject();
		System.out.println(a1);
		System.out.println(a2);
	}
}

com.itheima.d6_singleInstance.A@776ec8df
com.itheima.d6_singleInstance.A@776ec8df

单例模式的应用场景和好处?

任务管理器对象、获取运行时对象。
在这些业务场景下，使用单例模式，可以避免浪费内存。
饿汉式单例:拿对象时，对象早就创建好了，
懒汉式单例:拿对象时，才开始创建对象，

懒汉式单例设计模式

拿对象时，才开始创建对象

public class B{
	// 2、定义一个类变量，用于存储这个类的一个对象。
	private static B b;
	// 1、把类的构造器私有
	private B(){
	
	}
	
	//13、定义一个类方法，这个方法要保证第一次调用时才创建一个对象，后面调用时都会用这同一个对象返回。
	public static B getInstance(){
		if(b == null){
		b = new B();
		}
		return b;
	}
}

public class Test2 {
	public static void main(string[] args){
		B b1=B.getInstance();// 第一次拿对象
		B b2 =B.getInstance();
		System.out.println(b1 == b2);
	}
}

单例模式是用饿汉模式还是懒汉模式呢？

如果写的单例模式经常用就使用饿汉模式
如果写的单例模式不常用就用懒汉模式节省内存

1.4 final关键字

final 关键字是最终的意思，可以修饰(类、方法、变量)

修饰类:该类被称为最终类，特点是不能被继承了
修饰方法:该方法被称为最终方法，特点是不能被重写了
修饰变量:该变量只能被赋值一次。

// 1、final修饰类，类不能被继承了
final class A{}
//class B extends A {}

// 2、final修饰方法，方法不能被重写了
class C{
	public final void test()
}
class D extends C{
	@0verride
	public void test(){  //报错 
	}
}

public class Test{
	/**
	* 常量 : public static final 修饰的成员变量，建议名称全部大写，多个单词下划线连接
	*/
	public static final String SCHOOL_NAME ="黑马";
	private final String name ="猪八戒";// 这种用法没有意义，知道就行
	public static void main(string[] args){
		// 目标:认识final的作用。
		// 3、final可以修饰变量总规则:有且仅能赋值一次
		/*变量:
		1.局部变量
		2.成员变量：
			1、静态成员变量
			2、实例成员变量
		*/
		final int a;
		a= 12;
		//a=13;// 第二次赋值，出错了
		final double r= 3.14;
		//r=0.1;// 第二次赋值，出错了
		// schoolName =“白马";// 第二次赋值，出错了
	}
	
	public static void buy(final double z){
		//z= 0.1;// 第二次赋值，出错了
	}
}

final修饰变量的注意

final修饰基本类型的变量，变量存储的数据不能被改变
final修饰引用类型的变量，变量存储的地址不能被改变，但地址所指向对象的内容是可以被改变的。

final int[]arr ={11,22,33};
// arr = null;// 第二次赋值，出错了
arr[1]= 222;

常量
使用了 static final修饰的成员变量就被称为常量,
作用:通常用于记录系统的配置信息。
在这里插入图片描述

使用常量记录系统配置信息的优势、执行原理
代码可读性更好，可维护性也更好。
程序编译后，常量会被“宏替换”: 出现常量的地方全部会被替换成其记住的字面量这样可以保证使用常量和直接用字面量的性能是一样的。

public class Test2 {
	public static final String SCHOOL_NAME ='"黑马程序员黄埔班"
	public static void main(string[l args){// 目标:认识常量。
		System.out.println(SCHOOL_NAME);
		System.out.println(SCHOOL_NAME);
		System.out.println(SCHOOL_NAME);
		System.out.println(SCHOOL_NAME);
		System.out.println(SCHOOL NAME);
		System.out.println(SCHOOL NAME);
	}
}

HACKNOE

关注

25
点赞
踩
17

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java开发从入门到精通（九）：Java的面向对象OOP：成员变量、成员方法、类变量、类方法、代码块、单例设计模式，final关键字

Java的面向main方法使用static修饰也就说明main方法是类方法，Test.class在运行时会直接执行Test.main方法，所以main可以直接运行不需要别人调用，String[] args 代表main方法可以传参的，怎么传呢？java在编译执行的时候可以按照参数的类型直接传参，这是就是main方法的传参。类变量:有static修饰，属于类，在计算机里只有一份，会被类的全部对象共享。实例变量(对象的变量): 无static修饰，属于每个对象的。为什么工具类中的方法要用类方法，而不用实例方法?
复制链接

扫一扫