第5天
# 第5天
看了这么久，休息一下吧，是不是很简单，有疑问可以提出来呢？ 1,2,3，4天内容看熟练就行，坚持多看多看多看，记得喝水，多休息
在 Java 语言中，所有的变量在使用前必须声明。
# 变量的声明实例
int a, b, c; // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22; // 声明并初始化 z
String s = "Da"; // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x'; // 声明变量 x 的值是字符 'x'。
Java 语言支持的变量类型有：(学过就当复习了，多复习就好)
- 局部变量（Local Variables）：局部变量是在方法、构造函数或块内部声明的变量，它们在声明的方法、构造函数或块执行结束后被销毁，局部变量在声明时需要初始化，否则会导致编译错误。
public void exampleMethod() {
int localVar = 10; // 局部变量
// ...
}
- 实例变量（Instance Variables）：实例变量是在类中声明，但在方法、构造函数或块之外，它们属于类的实例，每个类的实例都有自己的副本，如果不明确初始化，实例变量会被赋予默认值（数值类型为0，boolean类型为false，对象引用类型为null）。
public class ExampleClass {
int instanceVar; // 实例变量
}
- 静态变量或类变量（Class Variables）：类变量是在类中用 static 关键字声明的变量，它们属于类而不是实例，所有该类的实例共享同一个 类变量 的值，类变量 在类加载时被初始化，而且只初始化一次。
public class ExampleClass {
static int classVar; // 类变量
}
- 参数变量（Parameters）：参数是方法或构造函数声明中的变量，用于接收调用该方法或构造函数时传递的值，参数变量的作用域只限于方法内部。
public void exampleMethod(int parameterVar) {
// 参数变量
// ...
}
# 实例
public class DaTest {
// 成员变量
private int instanceVar;
// 静态变量
private static int staticVar;
public void method(int paramVar) {
// 局部变量
int localVar = 10;
// 使用变量
instanceVar = localVar;
staticVar = paramVar;
System.out.println("成员变量: " + instanceVar);
System.out.println("静态变量: " + staticVar);
System.out.println("参数变量: " + paramVar);
System.out.println("局部变量: " + localVar);
}
public static void main(String[] args) {
DaTest v = new DaTest();
v.method(20);
}
}
运行以上代码，输出如下：
成员变量: 10
静态变量: 20
参数变量: 20
局部变量: 10
# Java 参数变量
Java 中的参数变量是指在方法或构造函数中声明的变量，用于接收传递给方法或构造函数的值。参数变量与局部变量类似，但它们只在方法或构造函数被调用时存在，并且只能在方法或构造函数内部使用。
accessModifier returnType methodName(parameterType parameterName1, parameterType parameterName2, ...) {
// 方法体
}
parameterType -- 表示参数变量的类型。
parameterName -- 表示参数变量的名称。
在调用方法时，我们必须为参数变量传递值，这些值可以是常量、变量或表达式。
方法参数变量的值传递方式有两种：值传递和引用传递。
# 值传递
值传递：在方法调用时，传递的是实际参数的值的副本。当参数变量被赋予新的值时，只会修改副本的值，不会影响原始值。Java 中的基本数据类型都采用值传递方式传递参数变量的值。
# 引用传递
引用传递：在方法调用时，传递的是实际参数的引用（即内存地址）。当参数变量被赋予新的值时，会修改原始值的内容。Java 中的对象类型采用引用传递方式传递参数变量的值。
# 方法参数变量的使用：
public class DaTest {
public static void main(String[] args) {
int a = 10, b = 20;
swap(a, b); // 调用swap方法
System.out.println("a = " + a + ", b = " + b); // 输出a和b的值
}
public static void swap(int x, int y) {
int temp = x;
x = y;
y = temp;
}
}
运行以上代码，输出如下：
a = 10, b = 20
# Java 局部变量
示例
public class DaTest {
public static void main(String[] args) {
int a = 10; // 局部变量
System.out.println("a = " + a);
}
}
运行以上代码，输出如下：
a = 10
# Java 实例变量
实例变量是在类中声明，但在方法、构造函数或块之外，它们属于类的实例，每个类的实例都有自己的副本，如果不明确初始化，实例变量会被赋予默认值（数值类型为0，boolean类型为false，对象引用类型为null）。
public class DaTest {
int a = 10; // 实例变量
public static void main(String[] args) {
DaTest obj = new DaTest();
System.out.println("a = " + obj.a);
}
}
运行以上代码，输出如下：
a = 10
# Java 静态变量
静态变量是在类中用 static 关键字声明的变量，它们属于类而不是实例，所有该类的实例共享同一个 类变量 的值，类变量 在类加载时被初始化，而且只初始化一次。
public class DaTest {
static int a = 10; // 静态变量
public static void main(String[] args) {
System.out.println("a = " + a);
}
}
运行以上代码，输出如下：
a = 10
# 说明
作用域：局部变量的作用域限于它被声明的方法、构造方法或代码块内。一旦代码执行流程离开这个作用域，局部变量就不再可访问。
生命周期：局部变量的生命周期从声明时开始，到方法、构造方法或代码块执行结束时终止。之后，局部变量将被垃圾回收。
初始化：局部变量在使用前必须被初始化。如果不进行初始化，编译器会报错，因为 Java 不会为局部变量提供默认值。
声明：局部变量的声明必须在方法或代码块的开始处进行。声明时可以指定数据类型，后面跟着变量名，例如：int count;。
赋值：局部变量在声明后必须被赋值，才能在方法内使用。赋值可以是直接赋值，也可以是通过方法调用或表达式。
限制：局部变量不能被类的其他方法直接访问，它们只为声明它们的方法或代码块所私有。
内存管理：局部变量存储在 Java 虚拟机（JVM）的栈上，与存储在堆上的实例变量或对象不同。
垃圾回收：由于局部变量的生命周期严格限于方法或代码块的执行，它们在方法或代码块执行完毕后不再被引用，因此JVM的垃圾回收器会自动回收它们占用的内存。
重用：局部变量的名称可以在不同的方法或代码块中重复使用，因为它们的作用域是局部的，不会引起命名冲突。
参数和返回值：方法的参数可以视为一种特殊的局部变量，它们在方法被调用时初始化，并在方法返回后生命周期结束。
局部变量存储在 Java 虚拟机（JVM）的栈上
存储在堆上的实例变量或对象
# 实例
public class LocalVariablesExample {
public static void main(String[] args) {
int a = 10; // 局部变量a的声明和初始化
int b; // 局部变量b的声明
b = 20; // 局部变量b的初始化
System.out.println("a = " + a);
System.out.println("b = " + b);
// 如果在使用之前不初始化局部变量，编译器会报错
// int c;
// System.out.println("c = " + c);
}
}
# 作用域
package com.Da.test;
public class Test{
public void pupAge(){
int age = 0;
age = age + 7;
System.out.println("小狗的年龄是: " + age);
}
public static void main(String[] args){
Test test = new Test();
test.pupAge();
}
}
以上实例编译运行结果如下:
小狗的年龄是: 7
# 变量没有初始化
所以在编译时会出错
package com.Da.test;
public class Test{
public void pupAge(){
int age;
age = age + 7;
System.out.println("小狗的年龄是 : " + age);
}
public static void main(String[] args){
Test test = new Test();
test.pupAge();
}
}
以上实例编译运行结果如下
Test.java:4:variable number might not have been initialized
age = age + 7;
^
1 error
# 成员变量（实例变量）
成员变量声明在一个类中，但在方法、构造方法和语句块之外。示例
public class DaTest {
int a = 10; // 成员变量a
public static void main(String[] args) {
DaTest obj = new DaTest();
System.out.println("a = " + obj.a); // 输出10
}
}
运行以上代码，输出如下：
a = 10
当一个对象被实例化之后，每个成员变量的值就跟着确定。示例
public class DaTest {
int a = 10; // 成员变量a
public static void main(String[] args) {
DaTest obj = new DaTest();
obj.a = 20;
System.out.println("a = " + obj.a); // 输出20
}
}
成员变量在对象创建的时候创建，在对象被销毁的时候销毁。示例
public class MyClass {
private int myVariable;
public MyClass(int value) {
myVariable = value;
}
public int getMyVariable() {
return myVariable;
}
public static void main(String[] args) {
MyClass obj = new MyClass(10);
System.out.println(obj.getMyVariable()); // 输出：10
obj = null; // 释放对象
System.gc(); // 建议垃圾回收器回收对象
}
}
在这个示例中，myVariable是一个成员变量，它在MyClass对象的创建时被初始化。在main方法中，我们创建了一个MyClass对象obj，并将它的myVariable设置为10。然后，我们将obj设置为null，这会使得obj不再引用原来的对象。最后，我们调用System.gc()来建议垃圾回收器回收对象。当垃圾回收器运行时，它会销毁obj所引用的对象，包括myVariable。
成员变量的值应该至少被 一个方法、构造方法或者语句块 引用，使得外部能够通过这些方式获取 实例变量信息。示例
public class MyClass {
private int myVariable;//实例变量
public MyClass(int value) {
myVariable = value;
}
public int getMyVariable() {
return myVariable;
}
public static void main(String[] args) {
MyClass obj = new MyClass(10);//实例变量
System.out.println(obj.getMyVariable()); // 输出：10
}
}
成员变量可以声明在使用前或者使用后。示例
public class MyClass {
private int myVariable;
public MyClass(int value) {
myVariable = value;
}
public int getMyVariable() {
return myVariable;
}
public static void main(String[] args) {
MyClass obj = new MyClass(10);
System.out.println(obj.getMyVariable()); // 输出：10
}
}
访问修饰符可以修饰成员变量。示例
public class MyClass {
private int myVariable;
public MyClass(int value) {
myVariable = value;
}
public int getMyVariable() {
return myVariable;
}
public static void main(String[] args) {
MyClass obj = new MyClass(10);
System.out.println(obj.getMyVariable()); // 输出：10
}
}
在这个示例中，myVariable是一个成员变量，它被声明为private，这意味着它只能在MyClass类内部访问。getMyVariable方法被用来获取myVariable的值，它是一个public方法，这意味着它可以在任何地方访问。因此，访问修饰符可以修饰成员变量，控制它的访问权限。
成员变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把成员变量设为私有。通过使用访问修饰符可以使成员变量对子类可见。示例
public class MyClass {
private int myVariable;
public MyClass(int value) {
myVariable = value;
}
public int getMyVariable() {
return myVariable;
}
public static void main(String[] args) {
MyClass obj = new MyClass(10);
System.out.println(obj.getMyVariable()); // 输出：10
}
}
public class SubClass extends MyClass {
public SubClass(int value) {
super(value);
}
public void printMyVariable() {
System.out.println(myVariable); // 可以访问父类的私有成员变量
}
}
在这个示例中，myVariable是一个成员变量，它被声明为private，这意味着它只能在MyClass类内部访问。getMyVariable方法被用来获取myVariable的值，它是一个public方法，这意味着它可以在任何地方访问。SubClass是MyClass的子类，它继承了MyClass的成员变量myVariable。SubClass的printMyVariable方法可以访问myVariable，因为myVariable是私有的，但是SubClass是MyClass的子类，所以它可以访问MyClass的私有成员变量。因此，成员变量对于 类中的方法、构造方法或者语句块 是可见的，一般情况下应该把成员变量设为私有，通过使用访问修饰符可以使成员变量对子类可见。
成员变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是 false，引用类型变量的默认值是 null。变量的值可以在声明时指定，也可以在构造方法中指定；
public class MyClass {
private int myInt;// 实例变量
// 声明一个布尔类型的私有变量
private boolean myBoolean;
// 声明一个字符串类型的私有变量
private String myString;
// 无参构造函数
public MyClass() {
// 初始化myInt为0
myInt = 0;
// 初始化myBoolean为false
myBoolean = false;
// 初始化myString为null
myString = null;
}
// 有参构造函数
public MyClass(int value, boolean flag, String str) {
// 将传入的value赋值给myInt
myInt = value;
// 将传入的flag赋值给myBoolean
myBoolean = flag;
// 将传入的str赋值给myString
myString = str;
}
public static void main(String[] args) {
MyClass obj1 = new MyClass();
System.out.println(obj1.myInt); // 输出：0
System.out.println(obj1.myBoolean); // 输出：false
System.out.println(obj1.myString); // 输出：null
MyClass obj2 = new MyClass(10, true, "Hello");
System.out.println(obj2.myInt); // 输出：10
System.out.println(obj2.myBoolean); // 输出：true
System.out.println(obj2.myString); // 输出：Hello
}
}
成员变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObjectReference.VariableName。
public class MyClass {
// 定义一个整型变量
private int myVariable;
// 构造方法，接收一个整型参数，并将其赋值给myVariable
public MyClass(int value) {
myVariable = value;
}
// 返回myVariable的值
public int getMyVariable() {
return myVariable;
}
public static void main(String[] args) {
MyClass obj = new MyClass(10);
System.out.println(obj.getMyVariable()); // 输出：10
System.out.println(MyClass.obj.myVariable); // 错误：无法直接访问私有成员变量
}
}
# 实例
public class DaTest {
private int a; // 私有成员变量a
public String b = "Hello"; // 公有成员变量b
public static void main(String[] args) {
DaTest obj = new DaTest(); // 创建对象
obj.a = 10; // 访问成员变量a，并设置其值为10
System.out.println("a = " + obj.a);// 输出：a = 10
obj.b = "World"; // 访问成员变量b，并设置其值为"World"
System.out.println("b = " + obj.b);// 输出：b = World
}
}
import java.io.*;
public class Employee{
// 这个成员变量对子类可见
public String name;
// 私有变量，仅在该类可见
private double salary;
//在构造器中对name赋值
public Employee (String empName){
name = empName;
}
//设定salary的值
public void setSalary(double empSal){
salary = empSal;
}
// 打印信息
public void printEmp(){
System.out.println("名字 : " + name );
System.out.println("薪水 : " + salary);
}
public static void main(String[] args){
Employee empOne = new Employee("Da");
empOne.setSalary(1000.0);
empOne.printEmp();
}
}
以上实例编译运行结果如下:
$ javac Employee.java
$ java Employee
名字 : Da
薪水 : 1000.0
# 类变量（静态变量）
类变量也称为静态变量，它们属于类，而不是类的实例。类变量使用 static 关键字声明，并且可以在没有创建类的实例的情况下访问。
Java 中的静态变量是指在类中定义的一个变量，它与类相关而不是与实例相关，即无论创建多少个类实例，静态变量在内存中只有一份拷贝，被所有实例共享。
静态变量在类加载时被创建，在整个程序运行期间都存在。
public class MyClass {
public static int count = 0;//静态变量 count ，其初始值为 0
// 其他成员变量和方法
}
访问方式
由于静态变量是与类相关的，因此可以通过类名来访问静态变量，也可以通过实例名来访问静态变量。
MyClass.count = 10; // 通过类名访问
MyClass obj = new MyClass();
obj.count = 20; // 通过实例名访问
# 生命周期
静态变量的生命周期与程序的生命周期一样长，即它们在类加载时被创建，在整个程序运行期间都存在，直到程序结束才会被销毁。因此，静态变量可以用来存储整个程序都需要使用的数据，如配置信息、全局变量等。
# 初始化时机
静态变量在类加载时被初始化，其初始化顺序与定义顺序有关。
如果一个静态变量依赖于另一个静态变量，那么它必须在后面定义。
public class MyClass {
public static int count1 = 0;
public static int count2 = count1 + 1;
// 其他成员变量和方法
}
# 常量和静态变量的区别
示例：
public class MyClass {
public static final int MY_CONSTANT = 10; // 常量
public static int myVariable = 20; // 静态变量
}
常量也是与类相关的，但它是用 final 关键字修饰的变量，一旦被赋值就不能再修改。与静态变量不同的是，常量在编译时就已经确定了它的值，而静态变量的值可以在运行时改变。另外，常量通常用于存储一些固定的值，如数学常数、配置信息等，而静态变量通常用于存储可变的数据，如计数器、全局状态等。
总之，静态变量是与类相关的变量，具有唯一性和共享性，可以用于存储整个程序都需要使用的数据，但需要注意初始化时机和与常量的区别。
# 静态变量的访问修饰符
静态变量的访问修饰符可以是 public、protected、private 或者默认的访问修饰符（即不写访问修饰符）。
示例：
public class MyClass {
public static int count = 0; // 公有静态变量
protected static int count2 = 0; // 受保护的静态变量
private static int count3 = 0; // 私有静态变量
static int count4 = 0; // 默认访问修饰符的静态变量
}
需要注意的是，静态变量的访问权限与实例变量不同，因为静态变量是与类相关的，不依赖于任何实例。
# 静态变量的线程安全性
静态变量是类级别的变量，它们在内存中只有一份拷贝，被所有实例共享。因此，静态变量在多线程环境下可能会出现线程安全问题。示例
public class MyClass {
public static int count = 0; // 静态变量
public static void increment() {
count++; // 增加count的值
}
}
在多线程环境下，多个线程可能会同时调用 increment() 方法，导致 count 的值被错误地增加多次。为了避免这种情况，可以使用同步机制来保证 count 的增加操作是线程安全的。
示例：
public class MyClass {
public static int count = 0; // 静态变量
public static synchronized void increment() {
count++; // 增加count的值
}
}
在 increment() 方法前面加上 synchronized 关键字，可以保证同一时刻只有一个线程可以执行该方法，从而避免了线程安全问题。
synchronized 关键字可以用于方法或代码块，用于保证代码块在多线程环境下的线程安全性。原理是 当一个线程进入 synchronized 方法或代码块时，它会获得该对象的一个锁，其他线程无法进入该对象的其他 synchronized 方法或代码块，直到该线程释放锁为止。
# 什么是线程：
线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
# 静态变量的命名规范
- 使用驼峰命名法
- 使用大写字母开头
- 使用有意义的名称
- 使用下划线分隔单词
- 使用前缀 "s_" 表示静态变量
public class MyClass {
// 使用驼峰命名法
public static int myStaticVariable;
// 使用大写蛇形命名法
public static final int MAX_SIZE = 100;
// 避免使用缩写
public static final String employeeName;
// 具有描述性的变量名
public static double defaultInterestRate;
}
在 main() 方法中，我们创建了三个 Counter 对象，并打印出了计数器的值。
public class Counter {
private static int count = 0;
public Counter() {
count++;
}
public static int getCount() {
return count;
}
public static void main(String[] args) {
Counter c1 = new Counter();
Counter c2 = new Counter();
Counter c3 = new Counter();
System.out.println("目前为止创建的对象数: " + Counter.getCount());
}
}
以上实例编译运行结果如下:
目前为止创建的对象数: 3