java基础学习

源文件声明规则

  • 一个源文件中只能有一个 public 类
  • 一个源文件中可以有多个非 public 类
  • 源文件的名称应该和 public 类的类名保持一致。例如：源文件中 public 类的类名是 Employee，那么源文件应该命名为Employee.java。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class Puppy {
    private int age;
    private String name;
 
    // 构造器
    public Puppy(String name) {
        this.name = name;
        System.out.println("小狗的名字是 : " + name);
    }
 
    // 设置 age 的值
    public void setAge(int age) {
        this.age = age;
    }
 
    // 获取 age 的值
    public int getAge() {
        return age;
    }
 
    // 获取 name 的值
    public String getName() {
        return name;
    }
 
    // 主方法
    public static void main(String[] args) {
        // 创建对象
        Puppy myPuppy = new Puppy("Tommy");
 
        // 通过方法来设定 age
        myPuppy.setAge(2);
 
        // 调用另一个方法获取 age
        int age = myPuppy.getAge();
        System.out.println("小狗的年龄为 : " + age);
 
        // 也可以直接访问成员变量（通过 getter 方法）
        System.out.println("变量值 : " + myPuppy.getAge());
    }
}

java基本数据类型

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

  • byte：字节型，8位，有符号整数，范围-128~127。
  • short：短整型，16位，有符号整数，范围-32768~32767。
  • int：整型，32位，有符号整数，范围-2147483648~2147483647。
  • long：长整型，64位，有符号整数，范围-9223372036854775808~9223372036854775807。
  • float：单精度浮点型，32位，范围-3.40282347E+38~3.40282347E+38。
  • double：双精度浮点型，64位，范围-1.7976931348623157E+308~1.7976931348623157E+308。
  • char：字符型，16位，表示单个Unicode字符。
  • boolean：布尔型，只有两个值：true和false。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
public class PrimitiveTypeTest {  
    public static void main(String[] args) {  
        // byte  
        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);  
        System.out.println("包装类：java.lang.Byte");  
        System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);  
        System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);  
        System.out.println();  
  
        // short  
        System.out.println("基本类型：short 二进制位数：" + Short.SIZE);  
        System.out.println("包装类：java.lang.Short");  
        System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);  
        System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);  
        System.out.println();  
  
        // int  
        System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);  
        System.out.println("包装类：java.lang.Integer");  
        System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);  
        System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);  
        System.out.println();  
  
        // long  
        System.out.println("基本类型：long 二进制位数：" + Long.SIZE);  
        System.out.println("包装类：java.lang.Long");  
        System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);  
        System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);  
        System.out.println();  
  
        // float  
        System.out.println("基本类型：float 二进制位数：" + Float.SIZE);  
        System.out.println("包装类：java.lang.Float");  
        System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);  
        System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);  
        System.out.println();  
  
        // double  
        System.out.println("基本类型：double 二进制位数：" + Double.SIZE);  
        System.out.println("包装类：java.lang.Double");  
        System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);  
        System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);  
        System.out.println();  
  
        // char  
        System.out.println("基本类型：char 二进制位数：" + Character.SIZE);  
        System.out.println("包装类：java.lang.Character");  
        // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台  
        System.out.println("最小值：Character.MIN_VALUE="  
                + (int) Character.MIN_VALUE);  
        // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台  
        System.out.println("最大值：Character.MAX_VALUE="  
                + (int) Character.MAX_VALUE);  
        
        // boolean  
        System.out.println("基本类型：boolean 二进制位数：" + Boolean.SIZE);  
        System.out.println("包装类：java.lang.Boolean");  
        System.out.println("true 的数值：" + Boolean.TRUE.hashCode());  
        System.out.println("false 的数值：" + Boolean.FALSE.hashCode());    
    }  
}

自动类型转换

Java语言支持自动类型转换，即不同类型的数据可以相互转换。

Java变量类型

Java语言提供了以下几种变量类型：

  • 局部变量：在方法、构造器或代码块中声明的变量，只能在声明它们的区域内使用。
  • 实例变量（成员变量）：在类的声明中声明的变量，可以被所有方法共享，包括方法体外。
  • 类变量（静态变量）：用 static 关键字修饰的变量，被所有对象共享，静态变量在第一次被访问时被初始化。
  • 常量：用 final 关键字修饰的变量，只能被赋值一次，常量可以是任何基本类型或引用类型。
  • 参数变量

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class RunoobTest {
    // 成员变量
    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) {
        RunoobTest v = new RunoobTest();
        v.method(20);
    }
}

参数变量

Java 中的参数变量是指在方法或构造函数中声明的变量，用于接收传递给方法或构造函数的值。参数变量与局部变量类似，但它们只在方法或构造函数被调用时存在，并且只能在方法或构造函数内部使用。

局部变量

Java 的局部变量是在方法、构造方法或语句块内部声明的变量，其作用域限制在声明它的代码块内部。

成员变量（实例变量）

成员变量（实例变量）是指在类的声明中声明的变量，可以被所有方法共享，包括方法体外。

类变量（静态变量）

Java 中的静态变量是指在类中定义的一个变量，它与类相关而不是与实例相关，即无论创建多少个类实例，静态变量在内存中只有一份拷贝，被所有实例共享。
静态变量在类加载时被创建，在整个程序运行期间都存在。

Java修饰符

Java 修饰符用来控制成员（类、方法、变量）的访问权限、继承性、多态性等。

访问控制修饰符

  • public：公共修饰符，可以被所有类访问，默认继承。
  • private：私有修饰符，只能被当前类访问。
  • protected：受保护修饰符，同包内的类可以访问，不同包的子类可以访问。
  • default：默认修饰符，同包内的类可以访问，不同包的子类不能访问。

非访问控制修饰符

  • abstract：抽象修饰符，用来创建抽象类和抽象方法。
  • final：最终修饰符，用来修饰类、方法、变量，防止它们被继承、修改。
  • static：静态修饰符，用来创建静态成员。
  • synchronized：同步修饰符，用来在多线程环境下同步访问资源。
  • volatile：易失修饰符，用来在多线程环境下保证变量的可见性。
  • transient：瞬时修饰符，用来在序列化时忽略该变量。

Java运算符

Java 运算符是用来执行各种操作的符号。Java 运算符分为以下几类：

  • 算术运算符

    用于执行基本的算术运算，如加减乘除、取模等。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    public class Test {
     
    public static void main(String[] args) {
       int a = 10;
       int b = 20;
       int c = 25;
       int d = 25;
       System.out.println("a + b = " + (a + b) );
       System.out.println("a - b = " + (a - b) );
       System.out.println("a * b = " + (a * b) );
       System.out.println("b / a = " + (b / a) );
       System.out.println("b % a = " + (b % a) );
       System.out.println("c % a = " + (c % a) );
       System.out.println("a++   = " +  (a++) );
       System.out.println("a--   = " +  (a--) );
       // 查看  d++ 与 ++d 的不同
       System.out.println("d++   = " +  (d++) );
       System.out.println("++d   = " +  (++d) );
      }
    }

  • 关系运算符

    用于比较两个值之间的关系，如大于、小于、等于、不等于等。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    public class Test {
     
    public static void main(String[] args) {
       int a = 10;
       int b = 20;
       System.out.println("a == b = " + (a == b) );
       System.out.println("a != b = " + (a != b) );
       System.out.println("a > b = " + (a > b) );
       System.out.println("a < b = " + (a < b) );
       System.out.println("b >= a = " + (b >= a) );
       System.out.println("b <= a = " + (b <= a) );
      }
    }