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

Java大数据开发和安全开发

（一)Java的变量和方法
- 1.1 成员变量
- 1.2 成员方法
- 1.3 static关键字
- - 1.3.1 static修饰成员变量
  - 1.3.1 static修饰成员变量的应用场景
  - 1.3.1 static修饰成员方法
  - 1.3.1 static修饰成员方法的应用场景
  - 1.3.1 static的注意事项
  - 1.3.1 static的应用知识:代码块
  - - 静态代码块
    - 实例代码块
  - 1.3.1 static的应用知识:单例设计模式
  - - 懒汉式单例设计模式

（一)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);
	}
}