【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 -versionjava 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.newout.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语句块用于捕捉异常：

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

字符串

来源地址：https://blog.csdn.net/jiangwei0512/article/details/132527955