Java入门级教程1——类的组成：驼峰命名法、入口函数、成员变量、数据类型

package com.hy.chapter1;

//文件名：Person.java（与类名一致）
public class Person {  // 类名使用大驼峰命名法
 private String firstName;  // 变量名使用小驼峰命名法
 private String lastName;   // 变量名使用小驼峰命名法
 
 // 构造方法名与类名一致
 public Person(String firstName, String lastName) {
     this.firstName = firstName;
     this.lastName = lastName;
 }
 
 // 方法名使用小驼峰命名法
 public String getFullName() {
     return firstName + " " + lastName;
 }
 
 // 静态常量使用全大写字母，单词间用下划线分隔
 public static final int MAX_AGE = 150;
}

1.3 注意事项

包名：Java 包名通常使用小写字母，避免使用大写字母，以防止命名冲突。
常量名：静态常量通常使用全大写字母，单词间用下划线分隔（如MAX_AGE）。

2. Java的入口函数是严格定义的

main是一个入口函数，是个特殊的函数：

1. 是不能够由开发者自行定义
2. 用static静态关键字修饰

//Java的入口函数,程序从哪个位置开始执行
//Java已经完全定义好了，不能够自定义
//java里面的static是表示最先被加载

public static void main(String[] args) {

}

详细解析：

public：访问修饰符，表示该方法可以被任何类访问。

static：静态修饰符，表示该方法属于类本身，而不是类的实例。因此，调用时无需创建对象。

void：返回类型，表示该方法不返回任何值。

main：方法名，Java 虚拟机 (JVM) 会识别这个特定名称作为程序的入口点。

String[] args：参数列表，是一个字符串数组，用于接收命令行参数。

3.Java在main方法中定义

3.1 定义的变量是局部变量，使用变量前必须初始化

3.1.1 局部变量在main方法中正常显示

package com.hy.chapter1;

public class User {
	
	public static void main(String[] args) {
		
		//main函数中可以定义的是变量和表达式
		//如果定义的是变量，就是局部变量
		//局部变量，只能作用于所在的函数main，main是一个特殊的函数，入口函数

		int  a = 10;  //赋值表达式
		System.out.println(a);  //输出表达式
		
	    //syso  alt+/  回车  快捷键
		
	}

}

输出结果：

10

3.1.2 在main方法外不能调用局部变量

package com.hy.chapter1;

public class User {
	
	public static void main(String[] args) {
		int  a = 10;  //赋值表达式
	}
	
	public   void   show(){
		//System.out.println(a); //报错！a是局部变量，定义在main函数内
	}
}

3.1.3 在使用前必须初始化

package com.hy.chapter1;

public class User {
	
	public static void main(String[] args) {
		//在main方法中可以定义局部变量，但必须在使用前初始化：
		int  a; 
		//System.out.println(a); //报错！
	}

}

3.2 表达式格式规范

3.2.1 局部变量定义时不能加访问修饰符[ public protected prviate ]
3.2.2 局部变量也不能加static关键字

3.3 不能在内部声明或定义函数

package com.hy.chapter1;

public class User {
	
	public static void main(String[] args) {
		//java里面的一个函数内部可以再定义一个函数吗？不可以。
		//因为：Java是一个纯面向对象的语言，同时它的面向函数式编程能力是不够的。
		//public void checkA() {}  //报错！
	}

}

4.Java的全局变量

类体中的变量，分为两个：（1）实例变量（2）静态变量（类变量）

4.1 实例变量

没有static修饰的变量实例化对象后使用的变量，这个变量属于这个对象

4.1.1 在main函数中不可以直接使用非静态变量（也就是实例变量），类变量

package com.hy.chapter1;

public class Emp {
	int  b  = 10;  

	public static void main(String[] args) {
	  	//System.out.println(b);  //错误
		//实例变量，实例化后才可以使用的变量
	}

}

4.1.2 实例变量，实例化后才可以使用

package com.hy.chapter1;

public class Emp {
	 
	int  b  = 10;  
	
	public static void main(String[] args) {
		//创建Emp这个类的对象,实例化的对象
		//类创建对象的模板   类名 对象名 =  new 类名( );
		//可以使用中文作为变量名，但是建议不使用
		Emp  emp  = new Emp();
		System.out.println(emp.b);	
	}

}

4.1.3 实例化对象后使用的变量，这个变量属于这个对象，也就是各自对象的。

package com.hy.chapter1;

public class Manager {
	//实例变量是属于每个对象的，是存放在堆内存空间的，是相互隔离的
	double  salay   =  10000.0;

	public static void main(String[] args) {	
		Manager m1 = new Manager();
		m1.salay   = 20000.0;
		System.out.println("m1.salary: " + m1.salay);
				
		Manager m2 = new Manager();
		System.out.println("m2.salary: " + m2.salay);
		//实例化对象后使用的变量，这个变量属于这个对象，也就是各自对象的。
	}
	
}

输出结果：

m1.salary: 20000.0
m2.salary: 10000.0

4.2 静态变量

static关键字修饰的变量，也叫做类变量，这个变量属于这个类的

4.2.1 在main函数中可以直接使用静态变量

package com.hy.chapter1;

public class Emp {

	static  int  c  = 20;  
	
	public static void main(String[] args) {
		//在main函数中可以直接使用静态变量，因为main就是一个static修饰的函数
		System.out.println(c);
	}

}

4.2.2 静态变量属于这个类的

package com.hy.chapter1;

public class Manager {
	// 职位名称  属于Manager这个类的
	static  String   manage  = "管理者";
	
	public static void main(String[] args) {
		Manager m2 = new Manager();
		
		//Java中静态变量可以用类名呼叫（建议），也可以对象名呼叫，造成了语法的多样性，但不严谨。
		Manager.manage  = "员工";
		System.out.println(Manager.manage);
		System.out.println(m2.manage);
	}

}

5.Java的数据类型

5.1 Java引用类型

5.1.1 默认值

// 作为全局变量，未手动初始化时，引用类型默认值为null

引用数据类型数组本身为null（未分配内存空间），此时试图访问其元素（如arrs2[0]），会触发NullPointerException（空指针异常），除非为其分配内存空间，才可访问其元素不出现异常。

package com.hy.chapter;

public class Test {
	static String arr; // String类
	static Integer arrs1; // 封装类
	static Test test; // 一般类
	static Integer[] arrs2 = new Integer[20]; // 引用数据类型数组已分配内存空间，但未赋值
	static Integer[] arrs3; // 引用数据类型数组未分配内存空间
	
	public static void main(String[] args) {
		System.out.println(arr); // null
		System.out.println(arrs1); // null
		System.out.println(test); // null
		System.out.println(arrs2[0]); // null
		System.out.println(arrs3); // null
		System.out.println(arrs3[0]); // NullPointerException（空指针异常）
	}

}

输出结果：

null
null
null
null

null
Exception in thread "main" java.lang.NullPointerException
at com.hy.chapter.Test.main(Test.java:16)

// 作为局部变量，Java不会赋予默认值，必须手动初始化后才能使用，否则会直接报编译错误

package com.hy.chapter;

public class Test {
	
	public static void main(String[] args) {
		String arr;
		Integer arrs1;
		Test test;
		Integer[] arrs2;
		Integer[] arrs3 = new Integer[20];
		
		//System.out.println(arr); // 报错！
		//System.out.println(arrs1); // 报错！
		//System.out.println(test); // 报错！
		//System.out.println(arrs2); // 报错！
		//System.out.println(arrs2[0]); // 报错！
		System.out.println(arrs3[0]); // null
	}

}

5.1.2 一般类

// 除了String类和封装类这两个类重写Object类的equals方法，比较的是对象的 “内容”
// 其他所有的类，equals方法都来自于Object类，比较的都是地址

package com.hy.chapter;

public class Test1 {
	
	public static void main(String[] args) {
		Test1  t1   =new Test1();
		Test1  t2   =new Test1();
		System.out.println(t1 == t2);//false 
		System.out.println(t1.equals(t2));//false
	}

}

输出结果：

false
false

5.1.3 String类

package com.hy.chapter1;

public class Test1 {
	
	public static void main(String[] args) {
		
		//String类型是Java中特殊的类型的两个其中之一：
		
		//String类型是个引用类型，但是自身的特殊在于：1.可以直接赋值  ；2. 也可以new对象
		String  s1 = "123";
		
		String  s2 = new String("123");
		
		//String是引用类型，== 比较的是地址
		System.out.println(s1 == s2);
		
		//判断是字符串的值是否相等equals 
		System.out.println(s1.equals(s2));//来自于String类自己定义的equals
		
	}

}

输出结果：

false
true

详细解释：

//s1还是声明在栈内存，"123"没有去new，它是存放在字符串池，这个池的概念是什么？
//池内存，就是：反复使用的一个内存地址。
String s1 = "123";

//java里面只要看到new，一定是堆内存开辟内存空间，内存空间会指向池中的存放"123"这个值的池内存。
String s2 = new String("123");

两种创建方式的内存差异（AI的详细解释）：

String s1 = "123";  // 方式1：字面量创建
String s2 = new String("123");  // 方式2：new关键字创建

s1 的创建过程：

1.JVM 先检查字符串池：是否有"123"？

2.若没有，在字符串池中创建"123"，并将s1（栈中的引用变量）指向池中这个"123"的地址。

3.后续若再用"123"创建字符串（如String s3 = "123"），会直接复用池中已有对象，s1 == s3，结果为true（引用相同）。

s2 的创建过程：

1.关键字new强制要求 JVM 在堆内存的普通区域（非字符串池）创建一个新的 String 对象。

2.同时，JVM 会检查字符串池：如果没有"123"，会先在池中创建"123"（保证常量存在）。

3.最终，堆中这个新对象会 “指向” 字符串池中"123"的内容（存储其引用），而s2（栈中的引用变量）指向堆中这个新对象的地址。

因此：

1. s1 == s2 结果为false（s1 指向池中的对象，s2 指向堆中新建的对象，地址不同）；

2. s1.equals(s2) 结果为true（内容都是"123"，String 重写了 equals 比较内容）。

思考：若字符串池中没有“123”，执行String s2 = new String("123") 会创建几个对象？

2个对象：

第一个对象：字符串池中的 "123" 常量对象

因为 JVM 在处理"123"这个字面量时，会先检查字符串池。由于池中原本没有 "123"，所以会在字符串池中新建一个 "123" 的字符串常量对象，用于后续复用。

第二个对象：堆内存普通区域的 String 对象

关键字new会强制 JVM 在堆内存的普通区域（非字符串池）新建一个 String 对象。这个对象会存储指向字符串池中 "123" 的引用（即共享池中的字符内容），而变量s2（栈中的引用）会指向堆中这个新创建的对象。

5.1.4 Integer封装类

// Integer类型就是int类型对应的class类的类型，封装类

package com.hy.chapter1;

public class Test3 {

	public static void main(String[] args) {
		Integer a1 = 10;
		Integer a2 = new Integer(10);
		// 比较地址
		System.out.println(a1 == a2);
		// 比较值
		System.out.println(a1.intValue() == a2.intValue());
	}

}

输出结果：

false
true

// 缓冲池 Integer复用对象范围 -128~127 ，到了128溢出缓冲池的范围，实际去new一个对象

package com.hy.test;

public class Test1 {

	public static void main(String[] args) { 
		Integer a1 = 123; 
		Integer a2 = 123; 
		System.out.println(a1 == a2); 
	} //true
	
}

package com.hy.test;

public class Test1 {

	public static void main(String[] args) { 
		Integer a1 = 128; 
		Integer a2 = 128; 
		System.out.println(a1 == a2); 
	} //false
	
}

5.1.5 Byte封装类

package com.hy.test;

public class Test1 {	
//	public static void main(String[] args) { 
//		Byte b1 = 128; 
//		Byte b2 = 128; 
//		System.out.println(b1 == b2); 
//	} //编译错误
}

package com.hy.test;

public class Test1 {
	
	public static void main(String[] args) { 
		Byte b1 = 127; 
		Byte b2 = 127; 
		System.out.println(b1 == b2); 
	} //true

}

5.1.6 Integer与Byte缓冲池区别

特性	`Byte`缓冲池	`Integer`缓冲池
范围	-128~127（覆盖`byte`全部取值）	默认 - 128~127（仅`int`的极小部分）
可调整性	不可调整	上限可通过 JVM 参数调整（下限固定）
缓冲池大小	固定 256 个对象	默认 256 个，调整后可增大
设计核心	全覆盖缓存（成本极低）	仅缓存高频小整数（平衡性能与内存）

思考：为什么下面这段代码运行结果为false,但将Integer换成Byte就变成了编译错误

public class Test1 {

        public static void main(String[] args) {

                Integer a1 = 128;

                Integer a2 = 128;

                System.out.println(a1 == a2); //false

        }

}

归结如下：

类型 128 的处理逻辑结果原因

Integer 128 在 int 取值范围内（int 范围更大），编译通过；但超出 Integer 缓冲池范围，自动装箱时创建新对象。 a1 == a2 为 false（地址不同）。

Byte 128 超出 byte 基本类型的取值范围（-128~127），编译阶段无法完成类型转换。直接编译错误（无法通过语法检查）。

类型	128 的处理逻辑	结果原因
`Integer`	`128` 在 `int` 取值范围内（`int` 范围更大），编译通过；但超出 `Integer` 缓冲池范围，自动装箱时创建新对象。	`a1 == a2` 为 `false`（地址不同）。
`Byte`	`128` 超出 `byte` 基本类型的取值范围（`-128~127`），编译阶段无法完成类型转换。	直接编译错误（无法通过语法检查）。

5.2 基本数据类型

5.2.1 作为全局变量，未手动初始化时，基本数据类型默认值如下

package com.hy.chapter;

public class Test {
	static byte a; //默认值为 0
	static short b; //默认值为 0
	static int c; //默认值为 0
	static long d; //默认值为 0
	static char e; //默认值为 空
	static float f; //默认值为 0.0
	static double g; //默认值为 0.0
	static boolean h; //默认值为 false

	public static void main(String[] args) {
		System.out.println("a: " + a);
		System.out.println("b: " + b);
		System.out.println("c: " + c);
		System.out.println("d: " + d);
		System.out.println("e: " + e);
		System.out.println("f: " + f);
		System.out.println("g: " + g);
		System.out.println("h: " + h);
	}

}

运行结果：

a: 0
b: 0
c: 0
d: 0
e:

f: 0.0
g: 0.0
h: false

5.2.2 基本数据类型数组本身为null（未分配内存空间），此时试图访问其元素（如arrs5[0]），会触发NullPointerException（空指针异常），除非为其分配内存空间，才可访问其元素不出现异常。

package com.hy.chapter;

public class Test {
	// static Integer[] arrs2 = new Integer[20]; // 引用数据类型数组已分配内存空间，但未赋值
	// static Integer[] arrs3; // 引用数据类型数组未分配内存空间

	static int[] arrs4 = new int[20];
	static int[] arrs5;
	
	public static void main(String[] args) {
		//System.out.println(arrs2[0]); // null
		//System.out.println(arrs3); // null
		//System.out.println(arrs3[0]); // NullPointerException（空指针异常）
		
		System.out.println(arrs4[0]);
		System.out.println(arrs5);
		System.out.println(arrs5[0]);
	}

}

0
null

Exception in thread "main" java.lang.NullPointerException
at com.hy.chapter.Test.main(Test.java:17)

5.2.3 作为局部变量，Java不会赋予默认值，必须手动初始化后才能使用，否则会直接报编译错误

package com.hy.chapter;

public class Test {

	public static void main(String[] args) {
		byte a; 
		short b; 
		int c;
		long d;
		char e; 
		float f;
		double g;
		boolean h; 
		// System.out.println("a: " + a); // 报错！
		// System.out.println("b: " + b); // 报错！
		// System.out.println("c: " + c); // 报错！
		// System.out.println("d: " + d); // 报错！
		// System.out.println("e: " + e); // 报错！
		// System.out.println("f: " + f); // 报错！
		// System.out.println("g: " + g); // 报错！
		// System.out.println("h: " + h); // 报错！
	}

}

5.2.4 基本数据类型数组也同样如此

package com.hy.chapter;

public class Test {
	
	public static void main(String[] args) {
		int[] arrs4 = new int[20];
		int[] arrs5;
		
		System.out.println(arrs4[0]); // 0
		// System.out.println(arrs5); // 报错！
		// System.out.println(arrs5[0]); // 报错！
	}

}

5.3 Java的引用类型和基本数据类型的机制

5.3.1 基本数据类型

若传递的是基本数据类型，传递的这个值的副本，无法改变原始定义的值

例1：

package com.hy.chapter1;

public class Test1 {
	
	public  static void change(int  value) {
		value  =20;
	}
	
	
	public static void main(String[] args) {
		int  value  = 10;
		change(value); //  value是int类型 ，int类型属于基本数据类型，传递是value的副本
		System.out.println("value的值是:"+value);//10
	}
	
}

运行结果：

value的值是:10

例2：

package com.hy.chapter1;

public class Test1 {
	
	public static void swap(int num1,int num2) {
		int temp = num1;
		num1 = num2;
		num2 = temp;
	}
	
	public static void main(String[] args) {
		int num1 = 10;
		int num2 = 20;
		swap(num1,num2);
		System.out.println(num1);
		System.out.println(num2);
	}

}

运行结果：

10
20

5.3.2 引用类型

如果是引用类型赋值，实际是把赋值的对象的地址给被赋值的对象，被赋值的对象和赋值对象的地址是一样的。

例1：

package com.hy.chapter1;

public class Test1 {
	
	int  value  = 10;
	
	public  static void change(int  value){
		value  =20;
	}
	
	public  static void change(Test1 t){
		t.value  =30;
	}
	
	
	public static void main(String[] args) {
		Test1 t1 = new Test1();
		System.out.println("value的值是:"+t1.value);//10
		
        // t1.value是int类型 ，int类型属于基本数据类型，传递是t1.value值的副本
		change(t1.value); 
		System.out.println("value的值是:"+t1.value);//10
		
        // t1是引用类型，传递的是t1的地址
		change(t1);
		System.out.println("value的值是:"+t1.value);//30
	}
	
}

运行结果：

value的值是:10
value的值是:10
value的值是:30

例2：

package com.hy.chapter1;

public class Test {

	int  a  = 10 ;
	
	public Test(){
	   a = 100;
	}
	
	public Test(int a){
		a = 200;
	}
	
	public  Test(Test  t){ //Test t = t1; //引用类型
		t.a =300;
	}
	
	public static void main(String[] args) {
	   Test  t1  = new Test();
	   System.out.println("Test类中t1.a的值为:"+ t1.a);//100

	   Test  t2  = new Test(50);
	   System.out.println("Test类中t2.a的值为:"+ t2.a);//10
	   
	   Test  t3  = new Test(t1);
	   System.out.println("Test类中t3.a的值为:"+ t3.a);//10
	   System.out.println("Test类中t1.a的值为:"+ t1.a);//300
	}

}

运行结果：

Test类中t1.a的值为:100
Test类中t2.a的值为:10
Test类中t3.a的值为:10
Test类中t1.a的值为:300

例3：

// 涉及局部新建对象

package com.hy.chapter1;

public class Test2 {
	
	int a = 10;
	
	public Test2() {
		
	}
	
	public Test2(Test2 t) {
    //Test2 t = t1，此时t指向main方法中的t1对应的堆内存(用堆内存存放实例对象)
		
		Test2 t1 = new Test2(); 
        //此处新建了一个t1，相当于局部变量，与main方法中的t1指向的堆内存无关
		t = t1;//把新创建的t1的地址同步给t，此时t与新创建的t1指向的堆内存相同
		t1.a = 300;//或t.a=300，结果不变
		//t与新创建的t1指向的堆内存中a的值为300
		
		//堆内存视图如下：
		//步骤一：t指向t1堆内存，新建t1(局部)，指向新的堆内存
		//t1   ---->   a = 10
		//t    ---↑
		//t1   ---->   a = 10
		
		//步骤二：把新创建的t1的地址同步给t
		//t1   ---->   a = 10
		//t    ---↓   
		//t1   ---->   a = 10
		
		//步骤三：改变t与新创建的t1指向的堆内存中a的值
		//t1   ---->   a = 10
		//t    ---↓   
		//t1   ---->   a = 300
	
	}
	
	public static void main(String[] args) {
		Test2 t1 = new Test2();
		System.out.println("Test类中t1.a的值为："+ t1.a);//10

		Test2 t2 = new Test2(t1);
		System.out.println("Test类中t2.a的值为："+ t2.a);//10
		System.out.println("Test类中t1.a的值为："+ t1.a);//10-->易错!!! 
	}

}

运行结果：

Test类中t1.a的值为：10
Test类中t2.a的值为：10
Test类中t1.a的值为：10

例4：

// 数组是引用类型！传递的是地址！（注意：数组分为引用数据类型和基本数据类型，这两种都是引用类型，传递的都是地址）

package com.hy.chapter1;

public class Test3 {

	public  static void change(int[]  arrs) {
		arrs[0] =100;
	}
	
	public static void main(String[] args) {
		int[]  arr = {1,2,3,4,5};
		
		System.out.println(arr[0]);
		
		change(arr);
		
		System.out.println(arr[0]);
	}

}

运行结果：

1
100

5.3.3 java与javascript中数组的使用

1.java数组是一个固定长度的类型一致的数据结构。

package com.hy.chapter1;

public class Test4 {
	
	public static void main(String[] args) {
		//java数组是一个固定长度的类型一致的数据结构。
		int[]  arrs = {3,4,6};
		arrs[3] =100;
		System.out.println(	arrs[3]);
	}

}

运行结果：// 索引超出数组有效范围

2.javascript数组是一个动态数组，可伸缩的数组，类型不要求一致

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
	</body>
	<script type="text/javascript">
	  let  arrs = [];
	  arrs[1] =100;
	  arrs[4] ="zhou";
	  console.log(arrs[0])
	  console.log(arrs[1])
	  console.log(arrs[2])
	  console.log(arrs[3])
	  console.log(arrs[4])
    </script>
</html>

运行结果：

undefined

100

undefined

undefined

zhou

2048 AI社区

有“AI”的1024 = 2048，欢迎大家加入2048 AI社区

更多推荐

[Dify x EdgeOne] 论文猎手——用 Dify + EdgeOne Pages 给科研人造一个每日 arXiv 速读助手

2048 AI社区

[Dify x EdgeOne] 哄睡童话机——用 Dify + EdgeOne Pages 给娃造一个会现挂的 AI 睡前故事神器

2048 AI社区

消息跨端架构演进：基于 C++ 的多端一致性研发框架实践

跨端不是追求 100% 代码复用。核心是在"一致性"与"平台最优体验"之间找到平衡点。对于强交互场景（如键盘区域），保留 Native 实现往往是更好的选择。容器框架的抽象层级要足够精简。过度设计会导致理解成本反增。我们的 BizLogicProtocol 只有 7 个核心方法，足以覆盖所有业务场景。全链路质量监控是成功落地的关键保障。跨端方案最怕的不是技术问题，而是出了问题找不到原因。架构合理性