【Java】Java基础

环境准备

安装JDK和JRE

下载JDK，可以在官网Java Downloads | Oracle 中国下载，但是这里需要注册才能够下载。在Index of java-local/jdk (huaweicloud.com)也可以下载到，但是版本比较老，关系不大，直接下载，对应jdk-8u202-windows-x64.exe，这个是JDK8版本，它是一个长期维护版本。

下载后安装：

注意这里的JRE，它是Java程序执行的环境，会有额外安装：

因为已经包含在下载包中，所以也不需要额外下载。

设置环境变量

安装成功之后需要增加Java相关的环境变量。

1. 首先是新建一个环境变量JAVA_HOME：

2. 再将JDK和JRE的bin目录添加到PATH变量中：

之后如果在PowerShell下可以使用java，就表示安装成功了，比如：

C:\Users\jiang>java
用法: java [-options] class [args...]
           (执行类)
   或  java [-options] -jar jarfile [args...]
           (执行 jar 文件)
其中选项包括:
    -d32          使用 32 位数据模型 (如果可用)
    -d64          使用 64 位数据模型 (如果可用)
    -server       选择 "server" VM
                  默认 VM 是 server.

    -cp <目录和 zip/jar 文件的类搜索路径>
    -classpath <目录和 zip/jar 文件的类搜索路径>
                  用 ; 分隔的目录, JAR 档案
                  和 ZIP 档案列表, 用于搜索类文件。
    -D<名称>=<值>
                  设置系统属性
    -verbose:[class|gc|jni]
                  启用详细输出
    -version      输出产品版本并退出
    -version:<值>
                  警告: 此功能已过时, 将在
                  未来发行版中删除。
                  需要指定的版本才能运行
    -showversion  输出产品版本并继续
    -jre-restrict-search | -no-jre-restrict-search
                  警告: 此功能已过时, 将在
                  未来发行版中删除。
                  在版本搜索中包括/排除用户专用 JRE
    -? -help      输出此帮助消息
    -X            输出非标准选项的帮助
    -ea[:<packagename>...|:<classname>]
    -enableassertions[:<packagename>...|:<classname>]
                  按指定的粒度启用断言
    -da[:<packagename>...|:<classname>]
    -disableassertions[:<packagename>...|:<classname>]
                  禁用具有指定粒度的断言
    -esa | -enablesystemassertions
                  启用系统断言
    -dsa | -disablesystemassertions
                  禁用系统断言
    -agentlib:<libname>[=<选项>]
                  加载本机代理库 <libname>, 例如 -agentlib:hprof
                  另请参阅 -agentlib:jdwp=help 和 -agentlib:hprof=help
    -agentpath:<pathname>[=<选项>]
                  按完整路径名加载本机代理库
    -javaagent:<jarpath>[=<选项>]
                  加载 Java 编程语言代理, 请参阅 java.lang.instrument
    -splash:<imagepath>
                  使用指定的图像显示启动屏幕
有关详细信息, 请参阅 http://www.oracle.com/technetwork/java/javase/documentation/index.html。

C:\Users\jiang>java -version
java version "1.8.0_202"
Java(TM) SE Runtime Environment (build 1.8.0_202-b08)
Java HotSpot(TM) 64-Bit Server VM (build 25.202-b08, mixed mode)

安装IDE

开发Java常用的IDE有Eclipse和IntelliJ IDEA，这里使用IntelliJ IDEA，它的Community版是免费的，界面如下：

创建Java项目：

示例代码：

到这里Java的基本环境已经安装完毕。

Java基础

Java主类结构

Java程序的基本组成单元是类。

每一个应用程序都必须要包含一个main()方法，含有main()方法的类称为主类。

一个Java程序有若干个类组成。

通过package关键字声明类所在的包，通过import关键字引入该包包含的类。

下面的代码声明了一个包，该包中包含一个类：

package LearnJava;

public class BasicDataType {
    public void test() {
        System.out.print(new BasicDataType());
    }
}

下面的代码包含并使用了上述类：

import LearnJava.BasicDataType;

public class Main {
    public static void main(String[] args) {
        // 基本数据类型测试
        BasicDataType myBasicDataType = new BasicDataType();
        myBasicDataType.test();
    }
}

public、static、void分别是权限修饰符、静态修饰符和返回值修饰符。

基本数据类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ymhpetO7-1693156098722)(Java.assets/基本数据类型.svg)]

Java没有区分正负的数值型，它们本身包含正负。

下面是一个示例：

package LearnJava;

public class BasicDataType {
    public byte byteValue = 0;
    public short shortValue = -1;
    public int intValue = 2;
    public long longValue = 3;
    public char charValue = 'a';
    public float floatValue = 1.1F; // 不加F会告警
    public double doubleValue = -1.2;
    public boolean booleanValue = true;

    public void test() {
        System.out.println(new BasicDataType());
        System.out.println(byteValue);
        System.out.println(shortValue);
        System.out.println(intValue);
        System.out.println(longValue);
        System.out.println(charValue);
        System.out.println(floatValue);
        System.out.println(doubleValue);
        System.out.println(booleanValue);
    }
}

变量和常量

Java语言严格区分大小写。

Java语言规定标识符有任意顺序的字母、下划线（_）、美元符号（$）和数字组成，并且第一个字符不能是数字。

Java关键字：

常量也被称为“final变量”，再整个程序中只能被赋值一次。

在Java语言中声明一个常量，除了要指定数据类型，还需要通过final关键字进行限定。

常量名通常使用大写字母，但这并不是必须的。

final double PI = 3.1425926;

在为所有的对象共享值时，常量是非常有用的。

根据变量的有效返回，变量可以分为：

• 成员变量：在类体中声明的变量被称为成员变量，成员变量在整个类中都有效。类中的成员变量又分为两类：静态变量和实例变量。
• 局部变量：在类的方法体中声明的变量称为局部变量。

运算符

算数运算符：

赋值运算法：

关系运算符：

逻辑运算符：

位运算符：

还有三元运算符?:也支持。

代码注释和编码规范

代码注释说明：

// 单行注释

/*
	多行
	注释
*/

/**
	文档注释
	注意上面有两个**
*/

一些编码规范：

1. package语句要写在类文件的第一行。如果类不在任何包中，可以不写package语句。
2. import语句写在类的上方，package语句下方。

流程控制

if语句：

if () {
    
} else if {} {
    
} else {
    
}

switch语句：

switch () {
    case x:
        break;
    case y:
        break;
    default:
        break;
}

循环语句：

while () {
    
}

do {
    
} while ();
    
for (x; y; z) {
    
}

for (i : a) {
    
}

控制语句：

break;
continue;

数组

• 声明一维数组：

int[] arr1;
// int arr2[];

第二种会在IDE中报告警：

Local variable 'arr2' has C-style array type declaration

所以还是建议使用数据类型[]的方式。

• 一维数组赋值：

public void testArray() {
    int[] arr1;
    arr1 = new int[5];
    for (int j : arr1) {
        System.out.println(j);
    }
}

• 声明的同时为一维数组分配内存：

int[] arr1 = new int[5];

• 初始化一维数组：

int[] arr1 = new int[] {1, 2, 3, 4, 5};
int[] arr2 = {10, 20, 30};

• 二维数组可以看做是特殊的一维数组。

int[][] arr3 = new int[2][4];

2是行数，4是列数：

• 二维数组的初始化：

int[][] arr4 = new int[][] {{1, 2, 3, 4}, {5, 6, 7, 8}};

arr3和arr4是等价的，但是不能直接写new int[2][4]，会报错。

这样写更能看出行列关系：

int[][] arr3 = new int[][] {
    {1, 2, 3, 4},
    {5, 6, 7, 8}
};

数组的基本操作

• 遍历：

int[][] arr3 = new int[][] {
    {1, 2, 3, 4},
    {5, 6, 7, 8}
};
for (int[] j : arr3) {
    for (int i : j) {
        System.out.println(i);
    }
}

foreach的方式很好用。

• 填充：

int[] arr2 = new int[3];

Arrays.fill(arr2, 1);
for (int i : arr2) {
    System.out.println(i);
}

为了使用fill()，需要导入对应的类：

import java.util.Arrays;

这里通过fill()为数组填充了同一个值。

还可以指定范围填充：

Arrays.fill(arr2, 0, 1, 10);

0表示起始位置，1表示结束位置（但该位置不在填充范围内），10表示需要填充的值。

• 排序：

int[] arr1 = new int[] {10, 2, 1, 4, 5};
Arrays.sort(arr1);
for (int i : arr1) {
    System.out.println(i);
}

• 复制数组：

int[] arr1 = new int[] {10, 2, 1, 4, 5};
int[] arr2 = Arrays.copyOf(arr1, 10);
for (int i : arr2) {
    System.out.println(i);
}

如果复制的值超过了原有的数组，则用0填充。

也有一个范围的版本：

int[] arr1 = new int[] {10, 2, 1, 4, 5};
int[] arr2 = Arrays.copyOfRange(arr1, 1, 2);
for (int i : arr2) {
    System.out.println(i);
}

通用结束的索引没有包含在内，所以上例中只复制一个值。

• 查询：

int[] arr1 = new int[] {10, 2, 1, 4, 5};
System.out.println(Arrays.binarySearch(arr1, 1));
System.out.println(Arrays.binarySearch(arr1, 0, arr1.length, 1));

返回的是索引值，同样可以指定范围。上例的返回值是2。

类和对象

面向对象的特性：

• 封装。
• 继承。
• 多态。

类示例：

package LearnJava;

public class Book {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

修饰符权限：

如果没有显式指定权限修饰符，则预设为包存取范围，即只有一个包中的类可以访问。

this关键字用于表示本类当前的对象，当前对象不是某个new出来的实体对象，而是当前正在编辑的类。this关键字只能在本类中使用。

构造函数：

public Book() {
    this.name = "Unspecific";
}
public Book(String name) {
    this.name = name;
}

如果类中没有定义构造方法，则会自动创建一个无参数的构造方法；如果已经有构造函数了，且都是带参数的，则不会有无参数的构造方法。

这里定义了两个构造函数，实际是中方法重载，即方法名相同，但是参数不同。

static定义类的静态变量或静态方法，它们在所有的实例中共享。静态成员同样有修饰符约束。

静态成员在类中可以不用this：

package LearnJava;

public class Book {
    private String name;
    public static int count = 0;

    public Book() {
        this.name = "Unspecific";
        count++;
    }
    public Book(String name) {
        this.name = name;
        count++;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void showBook() {
        System.out.format("Total count: %d\n", count);
        System.out.println(this.name);
    }
}

类的使用：

Book book1 = new Book();
Book book2 = new Book("Learning Java");
book1.showBook();
book2.showBook();

Object类

继承和多态

继承：

package LearnJava;

public class FictionBook extends Book {
    public FictionBook(String name) {
        super(name);
        System.out.println("FictionBook(String)");  // 这句要在上句下面，否则会报错
    }
}

super指向父类，这里是父类的构造函数。

使用：

Book book = new FictionBook("The Three-Body Problem");
book.showBook();

这里有一个向上转型，即子类对象转换成父类对象。

子类可以直接使用父类的函数。

多态是通过父类可以对它以及其子类都可以进行通用操作（其中也包含了向上转型）：

public static void checkBook(Book book) {
    if (book instanceof FictionBook) {
        System.out.println("This is a fiction book");
    } else if (book instanceof ReferenceBook) {
        System.out.println("This is a reference book");
    } else {
        System.out.println("This is a normal book");
    }
}

Book book1 = new FictionBook("The Three-Body Problem");
Book book2 = new ReferenceBook("XinHua Dictionary");
checkBook(book1);
checkBook(book2);

这里使用了instanceof关键字，可以用来判断对象的类型。

前面介绍过final变量，还有：

• final方法：防止子类修改父类的定义与实现方式，同时提高执行效率。
• final类：不能被继承。

Java只支持单继承。

抽象类与接口

抽象类使用abstract关键字定义。

抽象类不可实例化。

通过abstract关键字还可以定义抽象方法，该方法没有方法体，本身没有任何意义，必须要被重写（可以被它的直接子类重写，也可以被其子类的子类重写）。当然抽象类中也可以有正常的方法。

接口是纯粹的抽象类，所有方法都没有方法体。

使用interface关键字定义接口。

接口中方法必须要是public或abstract形式的，否则没有意义。

接口中定义的任何字段都默认是static和final的。

内部类

在一个类中使用内部类，可以在内部类中直接存起其所在类的私有成员变量。

package LearnJava;

public class OuterClass {
    private int x = 1;

    public class InnerClass {
        private int x = 11;

        public void show() {
            System.out.format("Inner int: %d\n", this.x);	// 只用内部类（就是它自己）的成员变量
            System.out.format("Outer int: %d\n", OuterClass.this.x);	// 使用外部类的成员变量
        }
    }

    public void show() {
        InnerClass inner = new InnerClass();
        inner.show();
    }
}

内部类的使用：

OuterClass out = new OuterClass();
OuterClass.InnerClass inner = out.new InnerClass(); // 内部类依赖于外部类的方法，所以必须要用out.new
out.show();
inner.show();

匿名类是只在创建对象时才会编写类体的一种方法。

匿名类的特点是“现用现写”。比如有一个抽象类：

package LearnJava;

public abstract class AnimalClass {
    String name;
    public abstract void sound();
}

这里临时使用：

AnimalClass dog = new AnimalClass() {
    @Override
    public void sound() {
        System.out.println("Wang ~ Wang ~");
    }
};
dog.sound();

异常

try-catch-finally语句块用于捕捉异常：文章来源地址https://www.toymoban.com/news/detail-678650.html

try {
    int a = 10 / 0;
}
catch (Exception e) {
    e.printStackTrace();
}
finally {
    System.out.println("Always be here");   // 无论是否异常都会执行
}

字符串

到了这里，关于【Java】Java基础的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！