java学习笔记（十） - 变量和类方法

执笔2022-08-142024-06-10

一、类变量

1. 定义

类变量也叫静态变量/静态属性，是该类的所有对象共享的变量,任何一个该类的对象去访问它时,取到的都是相同的值,同样任何一个该类的对象去修改它时，修改的也是同一个变量

2. 语法

//1. 定义类变量
//静态变量的访问修饰符的访问权限和范围和普通属性是一样的
//方式1
访问修饰符 static 数据类型 变量名;
//方式2
static 访问修饰符 数据类型 变量名;

//案例
class A{
    public static String name = "执笔";
    static public int num = 100;
}

//2. 访问类变量
类名.对象名;
对象名.类变量名;

3. 细节

使用场景：当需要某个类的所有对象都共享一个变量时
和普通实例变量（普通属性）的区别：类变量是该类所有对象共享的，而实例变量是每个对象独享的
实例变量不能通过类名.类变量名方式访问
static类变量在类加载的时候就生成了
类变量的生命周期随类的加载开始，随类的消亡而销毁

二、类方法

类方法也称为静态方法

1. 语法

//形式
访问修饰符 static 数据返回类型 方法名() {}
static 访问修饰符 数据返回类型 方法名() {}
//调用方式
类名.方法名
对象名.方法名

2. 使用场景

当方法中不涉及到任何和对象相关的成员，则可以将方法设计成静态方法，提高开发效率
将一些通用的方法设计为静态方法

3. 细节

类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区
类方法中无this的参数，普通方法中隐含着this的参数
类方法可以通过类名调用，也可以通过对象名调用
普通方法和对象有关，需要通过对象名调用，比如对象名.方法名(参数)，不能通过类名调用
类方法中不允许使用和对象有关的关键字，比如this和super。普通方法(成员方法)可以
类方法(静态方法)中只能访问静态变量或静态方法
普通成员方法，既可以访问普通变量(方法)，也可以访问静态变量(方法)

三、main方法

1	public static void main(String[] args) {}

main方法时虚拟机调用
java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public
java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static
该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数
java 执行的程序参数1参数2参数3
在main()方法中，我们可以直接调用main方法所在类的静态方法或静态属性
但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员

四、代码块

又称初始化块，属于类中的成员，类似于方法，将逻辑语句封装在方法体中{}
没有方法名、没有返回值、没有参数，只有方法体，不通过对象或类显示调用，而是加载类时，或创建对象时隐式调用

1. 语法

1
2
3

[修饰符]{
    //逻辑代码
};

修饰符可选,要写的话，也只能写static
代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的，叫普通代码块
逻辑语句可以为任何逻辑语句(输入、输出、方法调用、循环、判断等)
;号可以写上，也可以省略

2. 细节

代码块调用顺序优先于构造器
static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次
类被加载情况：
- 创建对象实例时new
- 创建子类对象实例，父类也会被加载
- 使用类的静态成员时（静态属性、静态方法）
普通的代码块，在创建对象实例时，会被隐式的调用。被创建一次，就会调用一次，如果只是使用类的静态成员时，普通代码块并不会执行

创建一个对象时，在一个类调用顺序：

① 调用静态代码块和静态属性初始化（注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用）
② 调用普通代码块和普通属性的初始化（注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用）
③ 调用构造方法

```java
public class CodeBlockExercise02 {

public static void main(String str[]) {
    Test a = new Test();//无参构造器
}

}

class Sample {

Sample(String s) {//有参构造器
    System.out.println(s);
}
Sample(){
    System.out.println( "Sample默认构造函数被调用");
}

}

class Test {

Sample sam1 = new Sample("sam1成员初始化");//(3)
static Sample sam = new Sample("静态成员sam初始化");//(1)

//静态代码块
static {
    System.out.println("static块执行");//(2)
    if (sam == null) System.out.println("sam is null");
}

//无参构造器
Test()
{
    System.out.println("Test默认构造函数被调用");//(4)
    }
}


- 构造器的最前面其实隐含了super()和调用晋通代码块，静态相关的代码块，属性初始化，在类加载时，就执行完毕，因此是优先于构造器和普通代码块执行的

```java
class A {
	public A(){//构造器
		//这里有隐藏的执行要求
    	//(1) super):
   	 	//(2)调用普通代码块的
		System.out.println("ok");
    }
}

创建一个子类时(继承关系)，静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序：
- ① 父类的静态代码块和静态属性（优先级一样，按定义顺序执行）
- ② 子类的静态代码块和静态属性（优先级一样,按定义顺序执行）
- ③ 父类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）
- ④ 父类的构造方法
- ⑤ 子类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）
- ⑥ 子类的构造方法
静态代码块只能直接调用静态成员(静态属性和静态方法),普通代码块可以调用任意成员

五、单例设计模式

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法

1. 创建步骤

构造器私有化
类的内部创建对象
向外暴露一个静态的公共方法
代码实现

2. 饿汉式

public class SingleTon {
    public static void main(String str[]) {
		//通过方法可以获取对象
		GirlFriend instance = GirlFriend.getInstance();
		System.out.println(instance);
        
		GirlFriend instance2 = tirlFriend.getInstance();
        System.out.println(instance2p;
    }
}

class GirlFriend {
	private String name;
	//为了能够在静态方法中，返回gf对象，需要将其修饰为static
	private static GirlFriend gf= new GirlFriend("小红红");//如何保障我们只能创建一个 		GirlFriend 对象
	//步骤
	//1. 将构造器私有化
    //2．在类的内部直接创建
	//3．提供一个公共的static方法，返回 gf对象
    private GirlFriend(String name) {
		this.name = name;
	}
	public static GirlFriend getInstance() {
		return gf;
	}
}

3. 懒汉式

//只能创建一个Cat封象
//使用单例模式
class cet {
	private String name;
	private static Cat cat ;
    //步骤
	//1. 构造器私有化
	//2. 定义一个static静态属性对象
	//3. 提供一个public的static方法，可以返回一个Cat对象
    private Cat(String name) {
		this.name = name;
	}
	public static Cat getInstance() {
		if(cat == null) {//如果遭没有斛建cat封象
			cat = new Cat("小可爱");
		}
	return cat;
}

4. 饿汉式与懒汉式对比

二者最主要的区别在于创建对象的时机不同：饿汉式是在类加载就创建了对象实例，而懒汉式是在使用时才创建
饿汉式不存在线程安全问题，懒汉式存在线程安全问题
饿汉式存在浪费资源的可能。因为如果程序员一个对象实例都没有使用，那么饿汉式创建的对象就浪费了，懒汉式是使用时才创建，就不存在这个问题
在我们javaSE标准类中，java.lang.Runtime就是经典的单例模式

六、Final关键字

final可以修饰类、属性、方法和局部变量

1. 使用场景

当不希望类被继承时，可以用final修饰
当不希望父类的某个方法被子类覆盖/重写(override)时,可以用final关键字
修饰
- ```java
访问修饰符 final 返回类型方法名
1
2
3
4
5

- 当不希望类的的某个属性的值被修改,可以用final修饰

- ```java
public final double TAX RATE=0.08

2. 细节

final修饰的属性又叫常量，一般用XX_XX_XX来命名

final修饰的属性在定义时，必须赋初始值，并且以后不能修改，赋值可以在以下位置之一：

① 定义时：

```java
public final double TAX_RATE=0.08;


- ② 在构造器中

  - ```java
    public A(){
        TAX_RATE = 1.1;
    }

③ 在代码块中

```java
{

TAX_RATE1 = 2.2;

}


- 如果final修饰的属性是静态的，则初始化的位置只能是：

  - ① 定义时
  - ②在静态代码块不能在构造器中赋值

- final类不能继承，但是可以实例化对象

- 如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承

- 一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法
- final不能修饰构造方法（即构造器）
- final和static往往搭配使用，效率更高，不会导致类加载，底层编译器做了优化处理

- 包装类（Integer,Double,Float, Boolean等都是final），String也是final

### 3. 案例

```java
public class FinalExercise01 {
    public static void main(String[] args) {
        new Circle(4).calArea();
    }
}

class Circle {
    private double radius;
    //1、在属性直接赋值
    //private final  double PI = 3.14;
    private final  double PI;
    private final  double PI2;

    {
        //2、在代码块中定义
        PI = 3.14;
    }
    public Circle(double radius) {
        this.radius = radius;
        //3、在构造器中定义
       PI2 = 3.14;
    }

    public  void calArea() {
        System.out.println(PI * (radius * radius));
    }
}

七、抽象类（Abstract）

1. 介绍

当父类的某些方法,需要声明，但是又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类

public class Abstract01 {
}
abstract class Animal{
    private String name;

    //这里eat 实现了，但没有什么意义
    //即：父类方法不确定性
    //1、将该方法设计为抽象(abstract)方法
    //2、所谓抽象方法就是没有实现的方法
    //3、没有实现就是指，没有方法体
    //4、当一个类中存在抽象方法时，需要将该类声明为abstract类
    //5、抽象类会被继承，由其子类来实现相关功能
//    public void eat() {
//        System.out.println("这是一个动物，但是不知道吃什么");
//    }
    public abstract void eat();
}

抽象类：用abstract关键字来修饰一个类

1	访问修饰符 abstract 类名{}

抽象方法：用abstract关键字来修饰一个方法

1	访问修饰符 abstract 返回类型方法名(参数列表);//没有方法体

2. 细节

抽象类不能被实例化
抽象类不一定包含abstract方法
一个类包含了abstract方法，则这个类必须声明为abstract
abstract只能修饰类和方法，不能修饰属性和其他的
抽象类可以有任意的成员，如：非抽象方法、构造器、静态属性等
抽象方法没有方法体
1
abstract void test();
如果一个类继承了抽象类，则它必须实现抽象类的所有方法，除非该类声明为abstract类

//如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类
abstract class E {
	public abstract void hi();
}
abstract class F extends E {
}
class G extends E {
	@Override
	public void hi() {//这里相等于G子类实现了父类E的抽象方法
	}
}

抽象方法不能用private、final、static来修饰，这些关键字都是和重写相违背

八、接口

1. 介绍

接口就是给出一些没有实现的方法，封装到一起,到某个类要使用的时候，在根据具体情况把这些方法写出来
接口中默认抽象方法和常量

2. 语法

interface 接口名{
    //属性
    //方法
}

//一个类实现接口
class 类名 implements 接口名{
    //该类属性
    //该类方法
    //必须实现的接口的抽象类
}

Jdk7.0前接口里的所有方法都没有方法体
Jdk8.0后接口类可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现

public interface AInterface {
	//写属性
	public int n1 = 10;//写方法
	//在接口中，抽象方法，可以省略abstract关键字
    public void hi();
	//在jdk8后，可以有默认实现方法，需要使用default关键字修饰
    default public void ok() {
		system.out.println("ok ...");
	}
    //在jdk8后，可以有静态方法
    public static void cry() {
		System.out.println("cry ....");
    }
}

3. 细节

接口不能被实例化

接口中所有的方法都是public方法，接口中抽象方法可以不用abstract修饰

```java
void test();//等价于abstract void test();


- 一个普通类实现接口，则必须实现该接口的所有方法

- 抽象类实现接口，可以不用实现接口的方法

- 一个类同时可以实现多个接口

- 接口中的属性只能是final

  - ```java
    public static final 修饰符
    int a = 1;//实际上是public static final int a = 1;必须初始化

接口中的访问形式

```java
接口名.属性名


- 一个接口不能继承其他的类，但是可以继承多个别的接口

- 接口的修饰符只能是public 和 默认，和类的修饰符一致

### 4. 接口的多态特性

- **多态参数**：接口可以指向实现了接口类的对象
- **多态数组**
- **多态传递**

## 九、内部类

### 1. 介绍

- 一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class),嵌套其他类的类称为外部类(outer class)

- **类的五大成员：属性、方法、构造器、代码块、内部类**

### 2. 语法

```java
class Outer{//外部类
    class Inner{//内部类
        
    }
}
class Other{//外部其他类
    
}

3. 分类

3.1 定义在外部类的局部位置

3.1.1 局部内部类

有类名
可以直接访问外部类的所有成员，包含私有的
不能添加访问修饰符，因为它的地位就是一个局部变量，局部变量是不能使用修饰符的，但是可以使用final修饰，因为局部变量也可以使用final
作用域：仅仅在定义它的方法或代码块中
局部内部类—-访问——>外部类的成员[访问方式：直接访问]
外部类—-访问——>局部内部类的成员[访问方式：创建对象，再访问(注意：必须在作用域内)]
外部其他类—-不能访问——->局部内部类（因为局部内部类地位是一个局部变量)

如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

```java
System.out.println(“外部类的n2= “ + 外部类名.this.n2);


```java
class Outer02 {//外部类
	private int n1 = 100;
    public void m1() {//方法
		//局部内部类是定义在外部类的局部位置,通常在方法
        //不能添加访问修饰符，但是可以使用final修饰
        //作用域：仅仅在定义它的方法或代码块中
        final class Inner02 {//局部内部类
            private int n1 = 800;
            //可以访问外部类的所有成员，包含私有的
            public void f1(){
                System.out.println("n1= " + n1 + " 外部类的n1= " + Outer02.this.n1);
            }
		}
        //外部类在方法中，可以创建Inner02对象
        Inner02 inner02 = new Inner02();
        inner02.f1();
	}
}

3.1.2 匿名内部类

没有类名

//语法
new 类或接口(参数列表){
   //类体 
};

//方式1
IA tiger = new IA() {
	@Override
	public void cry() {
		System.out.println("老虎叫唤... ");
	}
};
tiger.cry();

//方式2
new IA() {
	@Override
	public void cry() {
		System.out.println("老虎叫唤... ");
	}
}.cry();

匿名内部类使用一次，就不能再使用了
匿名内部类可以调用其本身的方法
可以直接访问外部类的所有成员,包含私有的
不能添加访问修饰符,因为它的地位就是一个局部变量
作用域：仅仅在定义它的方法或代码块中
匿名内部类—-访问——>外部类成员[访问方式:直接访问]
外部其他类—-不能访问——->匿名内部类（因为匿名内部类地位是一个局部变量)
如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则,如果想访问外部类部成员，则可以使用(外部类名.this.成员）去访问

3.2 定义在外部类的成员位置

3.2.1 成员内部类

没有使用static修饰
可以直接访问外部类的所有成员

class Outer01{//外部类
    private int n1 = 10;
	public String name = "张三";
    class InnterO1{
		public void say(){
			System.out.printIn("Outer01的n1 = " + n1 + " outer01的name = " + name );
}}}

可以添加任意访问修饰符（public、protected、默认、private）
作用域：在外部类的成员方法中创建成员内部类，在调用方法
成员内部类—-访问——>外部类[访问方式：直接访问]
外部类—-访问———>内部类[访问方式：创建对象，再访问]
外部其他类—-访问——>成员内部类
如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

3.2.2 静态内部类

1	static class Inner01{}

使用static修饰
可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
可以添加任意访问修饰符(public.protected、默认、private)，因为它的地位就是一个成员
作用域：同其他的成员，为整个类体
静态内部类—-访问——>外部类(比如：静态属性)[访问方式：直接访所有静态成员]

外部类—-访问———>静态内部类[访问方式：创建对象，再访问]

```java
class A03{

private int n1 = 10;
private static String name = "tom";
private static void cry(){
    System.out.println("cry" );
}
//定义一个静态内部类
static class BO2{
    public void say(){
        System.out.print1n(name);cry();
    }
}
public void test(){
    B02 b02 = new B02();
    b02.say();
}

}


- 外部其他类---访问----->静态内部类

  - ```java
    public class TestInnerDemo3 {
    	public static void main(String[] args) {
    		//二种方式
    		B02 b02_1 = new A03.B02();//这里就不会创建一个A03对象实例
            b02_1.say();
    		B02 b02_2 = new A03().getBo20bject();//第二方式
    	}
    }