Martian148's blog
martian148
2025-05-26
目录

Java基础语法

一个 Java 程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。

# 基本语法

  • 大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。

  • 类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。

  • 方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。

  • 源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。（如果文件名和类名不相同则会导致编译错误）

  • 主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。

# 基础概念

  • 对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
  • 类：类是一个模板，它描述一类对象的行为和状态。
  • 方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
  • 实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。

# Java 标识符

  • 所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始
  • 首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合

# Java修饰符

  • 访问控制修饰符 : default, public , protected, private
  • 非访问控制修饰符 : final, abstract, static, synchronized

# Java 变量

  • 局部变量
  • 类变量（静态变量）
  • 成员变量（非静态变量）

# Java注释

public class HelloWorld {
   /* 这是第一个Java程序
    * 它将输出 Hello World
    * 这是一个多行注释的示例
    */
    public static void main(String[] args){
       // 这是单行注释的示例
       /* 这个也是单行注释的示例 */
       System.out.println("Hello World"); 
    }
}
1
2
3
4
5
6
7
8
9
10
11

# Java 源程序与编译型运行区别

image.png

# 对象和类

# 创建对象

对象是根据类创建的。在Java中，使用关键字 new 来创建一个新的对象。创建对象需要以下三步：

  • 声明：声明一个对象，包括对象名称和对象类型。
  • 实例化：使用关键字 new 来创建一个对象。
  • 初始化：使用 new 创建对象时，会调用构造方法初始化对象。
public class hello {
    public hello(String name){
        //这个构造器仅有一个参数：name
        System.out.println("小狗的名字是 : " + name ); 
     }
    public static void main(String[] args){
        hello A = new hello("xiaohai");
    }
}
1
2
3
4
5
6
7
8
9

我们有个叫hello的类，这个类里面有个构造函数需要一个参数name，我们new了一个对象，把这个对象命名为A，这个对象的name属性叫做xiaohai

# 源文件声明规则

  • 一个源文件中只能有一个 public 类
  • 一个源文件可以有多个非 public 类
  • 源文件的名称应该和 public 类的类名保持一致。例如：源文件中 public 类的类名是 Employee，那么源文件应该命名为Employee.java。
  • 如果一个类定义在某个包中，那么 package 语句应该在源文件的首行。
  • 如果源文件包含 import 语句，那么应该放在 package 语句和类定义之间。如果没有 package 语句，那么 import 语句应该在源文件中最前面。
  • import 语句和 package 语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明

# import 语句

下面的命令行将会命令编译器载入 java_installation/java/io 路径下的所有类

import java.io.*;
1

# 基本数据类型

java的数据类型包括两种

# 内置数据类型

byte：

  • byte 数据类型是8位、有符号的，以二进制补码表示的整数；
  • 最小值是 -128（-2^7），最大值是 127（2^7-1）；

short：

  • short 数据类型是 16 位、有符号的以二进制补码表示的整数
  • 最小值是 -32768（-2^15），最大值是 32767（2^15 - 1）；
  • Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；

int：

  • int 数据类型是32位、有符号的以二进制补码表示的整数；
  • 最小值是 -2,147,483,648（-2^31），最大值是 2,147,483,647（2^31 - 1）；
  • 一般地整型变量默认为 int 类型；

long：

  • long 数据类型是 64 位、有符号的以二进制补码表示的整数；
  • 最小值是 -9,223,372,036,854,775,808（-2^63）；
  • 最大值是 9,223,372,036,854,775,807（2^63 -1）；
  • 这种类型主要使用在需要比较大整数的系统上；
  • 例子： long a = 100000L，long b = -200000L。 "L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

float：

  • float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
  • float 在储存大型浮点数组的时候可节省内存空间；
  • 浮点数不能用来表示精确的值，如货币；

double：

  • double 数据类型是双精度、64 位、符合 IEEE 754 标准的浮点数；
  • 浮点数的默认类型为 double 类型；
  • double类型同样不能表示精确的值，如货币；

boolean：

  • boolean数据类型表示一位的信息；
  • 只有两个取值：true 和 false；
  • 默认值是 false；

char：

  • char 类型是一个单一的 16 位 Unicode 字符；
  • 最小值是 \u0000（十进制等效值为 0），最大值是 \uffff（即为 65535）；

实际上，JAVA中还存在另外一种基本类型 void，它也有对应的包装类 java.lang.Void，不过我们无法直接对它们进行操作。

# 引用类型

  • 在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
  • 对象、数组都是引用数据类型。
  • 所有引用类型的默认值都是null。
  • 一个引用变量可以用来引用任何与之兼容的类型。
  • 例子：Site site = new Site("Runoob")

# Java 常量

在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似

final double PI = 3.1415927;
1

byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。

当使用字面量的时候，前缀 0 表示 8 进制，而前缀 0x 代表 16 进制

# Java 变量类型

type identifier [ = value][, identifier [= value] ...] ;
1
  • type -- 数据类型。
  • identifier -- 是变量名，可以使用逗号 , 隔开来声明多个同类型变量。

Java 语言支持的变量类型有：

  • 局部变量（Local Variables）：定义在方法、构造方法或语句块中的变量，作用域只限于当前方法、构造方法或语句块中。局部变量必须在使用前声明，并且不能被访问修饰符修饰。
  • 成员变量（Instance Variables）：定义在类中、方法之外的变量，作用域为整个类，可以被类中的任何方法、构造方法和语句块访问。成员变量可以不初始化使用，成员变量可以被访问修饰符修饰。
  • **静态变量（Class Variables）：**定义在类中、方法之外的变量，并且使用 static 关键字修饰，作用域为整个类，可以被类中的任何方法、构造方法和语句块访问，静态变量的值在程序运行期间只有一个副本。静态变量可以被访问修饰符修饰。
  • **参数变量（Parameters）：**方法定义时声明的变量，作为调用该方法时传递给方法的值。参数变量的作用域只限于方法内部。
public class RunoobTest {
    // 成员变量
    private int instanceVar;
    // 静态变量
    private static int staticVar;
    
    public void method(int paramVar/*参数变量*/) {
        // 局部变量
        int localVar = 10;
        
    }
    
    public static void main(String[] args) {
        RunoobTest v = new RunoobTest();
        v.method(20);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# Java 修饰符

# 访问控制修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

  • default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
  • private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
  • public : 对所有类可见。使用对象：类、接口、变量、方法
  • protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

# 非访问修饰符

  • static 修饰符，用来修饰类方法和类变量。

  • final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。

  • abstract 修饰符，用来创建抽象类和抽象方法。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。

  • synchronized 和 volatile 修饰符，主要用于线程的编程

# Java 运算符

# Java 循环结构

for, while 及 do...while

# Java switch case 语句

switch(expression){
    case value :
       //语句
       break; //可选
    case value :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}
1
2
3
4
5
6
7
8
9
10
11

# Java Number

然而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每一个内置数据类型提供了对应的包装类。

所有的包装类**（Integer、Long、Byte、Double、Float、Short）**都是抽象类 Number 的子类。

# Java Math 类

Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。

Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。

public class Test {  
    public static void main (String []args)  
    {  
        System.out.println("90 度的正弦值：" + Math.sin(Math.PI/2));  
        System.out.println("0度的余弦值：" + Math.cos(0));  
        System.out.println("60度的正切值：" + Math.tan(Math.PI/3));  
        System.out.println("1的反正切值： " + Math.atan(1));  
        System.out.println("π/2的角度值：" + Math.toDegrees(Math.PI/2));  
        System.out.println(Math.PI);  
    }  
}
1
2
3
4
5
6
7
8
9
10
11

# Java String 类

如何创建

String str = "Runoob";
1

或者

String str2=new String("Runoob");
1

String 创建的字符串存储在公共池中，而 new 创建的字符串对象在堆上：

# Java StringBuffer和 StringBuilder 类

在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。

StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。

# Java 数组

创建数组

int[] A = new int[10];
1

处理数组的时候可以使用For-Each 循环

for(type element: array){
    System.out.println(element);
}
1
2
3

数组可以作为参数传递给方法

public static void printArray(int[] array) {
  for (int i = 0; i < array.length; i++) {
    System.out.print(array[i] + " ");
  }
}
printArray(new int[]{3, 1, 2, 6, 4, 2});
1
2
3
4
5
6

数组也可以作为函数的返回值

public static int[] reverse(int[] list) {
  int[] result = new int[list.length];
 
  for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
    result[j] = list[i];
  }
  return result;
}
1
2
3
4
5
6
7
8

# 多维数组

String[][] str = new String[3][4];
1

# Arrays 类

ava.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

具有以下功能：

  • 给数组赋值：通过 fill 方法。
  • 对数组排序：通过 sort 方法,按升序。
  • 比较数组：通过 equals 方法比较数组中元素值是否相等。
  • 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

# Java 方法

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}
1
2
3
4
5
6

# 命令行参数的使用

有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main()函数实现。

命令行参数是在执行程序时候紧跟在程序名字后面的信息。

public class CommandLine {
   public static void main(String[] args){ 
      for(int i=0; i<args.length; i++){
         System.out.println("args[" + i + "]: " + args[i]);
      }
   }
}
1
2
3
4
5
6
7

这样在编译的时候就会跟在后面了

# 可变参数

typeName... parameterName
1

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

public static void printMax( double... numbers) {
        if (numbers.length == 0) {
            System.out.println("No argument passed");
            return;
        }
 
        double result = numbers[0];
 
        for (int i = 1; i <  numbers.length; i++){
            if (numbers[i] >  result) {
                result = numbers[i];
            }
        }
        System.out.println("The max value is " + result);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# finalize() 方法

析构函数，在对象被回收之前调用

protected void finalize()
{
   // 在这里终结代码
}
1
2
3
4

# Java 流(Stream)、文件(File)和IO

# 读取控制台输入

我们首先需要创建一个BufferedReader，把System.in 封装在里面

BufferedReader br = new BufferedReader(new 
                      InputStreamReader(System.in));
1
2

想要读取一个字符就需要使用read()方法

每次调用 read() 方法，它从输入流读取一个字符并把该字符作为整数值返回。 当流结束的时候返回 -1。该方法抛出 IOException。

//使用 BufferedReader 在控制台读取字符
 
import java.io.*;
 
public class BRRead {
    public static void main(String[] args) throws IOException {
        char c;
        // 使用 System.in 创建 BufferedReader
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("输入字符, 按下 'q' 键退出。");
        // 读取字符
        do {
            c = (char) br.read();
            System.out.println(c);
        } while (c != 'q');
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

从标准输入读取一个字符串需要使用 BufferedReader 的 readLine() 方法。

String str=br.readLine()
1

# 控制台输出

println

# 读写文件

可以使用字符串类型的文件名来创建一个输入流对象来读取文件：

InputStream f = new FileInputStream("C:/java/hello");
1

也可以使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象：

File f = new File("C:/java/hello"); InputStream in = new FileInputStream(f);
1

使用字符串类型的文件名来创建一个输出流对象：

OutputStream f = new FileOutputStream("C:/java/hello")
1

也可以使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象：

File f = new File("C:/java/hello"); OutputStream fOut = new FileOutputStream(f);
1

当然我们也可以是用Scanner来输入

需要调用java.util.Scanner

Scanner scan = new Scanner(System.in);
1

有两个操作，next和nextLine

nextLine可以有空格，读整行

开发环境配置
计算机组成原理笔记

← 计算机组成原理笔记→

最近更新
01
开发环境配置
05-26
02
pink 老师 JavaScript 学习笔记
05-26
03
参赛准备
05-26
更多文章>
Theme by Vdoing | Copyright © 2024-2025 Martian148 | MIT License