CLion 的安装

首先推荐前往CLion官网下载正版，当然正版需要花钱购买使用时间，可以免费体验一个月。

如果你想免费使用永久，你需要下载较低版本，如 CLion-2021.1.3，我已在某个群发布。

下载完成后，双击打开，点击Next。

选择安装位置，不推荐安装在C盘。

看不懂直接全部打钩完事#[doge]

点击Install，等待安装完成，点击Finish。

安装完成以后双击打开CLion，点击Eval For Free，可以免费试用一个月，此处因为我已安装完成，就不再演示了。

永久免费试用教程，点击查看，此处不再赘述。

本文将逐个介绍 Java 的基础类型，使各位对 Java 的基础变量类型有更深的了解。

基础变量类型介绍

int

• int类型是声明一个变量为整数型。
• 占用内存32位。
• 范围为 -2 ^ 31 ~ 2 ^ 31 - 1。
• 默认值为0。

short

• short类型是声明一个变量为短整型。
• 占用内存16位。
• 范围为 -2 ^ 15 ~ 2 ^ 15 - 1。
• 默认值为0。

long

• long类型是声明一个变量为长整型。
• 占用内存64位。
• 范围为 -2 ^ 63 ~ 2 ^ 63 - 1。
• 默认值为 0L。
• 声明需注意，数字后跟L，例如：long a = 2000L;

float

• float类型是声明一个变量为单精度、符合IEEE 754标准的浮点数。
• 占用内存32位。
• 默认值为 0.0f。
• 声明需注意，数字后跟f，例如 float b = 3.14f。
• float类型不能用于表达精确值！

double

• double类型是声明一个变量为双精度、符合IEEE 754标准的浮点数。
• 占用内存32位。
• 默认值为 0.0d。
• double类型同样不能用于表达精确值！
• 当一个浮点数未明确声明为float型时，默认为double型

boolean

• boolean类型是声明一个变量为布朗逻辑型。
• 占用内存为1位。只有 true 与 false 两种值。
• 默认值为 false。

byte

• byte类型是声明一个变量为以二进制补码表示的整数。
• 占用内存8位。
• 范围为 -128 ~ 127。
• 默认值为0。

char

• short类型是声明一个变量为Unicode字符。

• 占用内存为16位。

• 可以存储任何字符。

注意 String 不是基础变量。

基础变量类型间的转换

隐式转换

隐式转换的意思是，不通过显式声明，由程序默认按优先级高低从低级向高级转换。

1
2

低级 -> 高级
byte,short,char —> int —> long —> float —> double 

例如：

1
2
3
4
5
6

char c1='a';
int i1 = c1; //char自动类型转换为int
System.out.println("char 自动类型转换为 int 后的值等于 " + i1);
char c2 = 'A';
int i2 = c2+1; //char 类型和 int 类型计算
System.out.println("char 类型和 int 计算后的值等于 " + i2);

此时输出的结果为

1
2

char 自动类型转换为 int 后的值等于 97
char 类型和 int 计算后的值等于 66

显式转换

显式转换的意思是，通过显式声明，将一个变量类型转换成另一变量类型，如

1
2

int i = 1;   
byte b = (byte) i;

显式类型需要注意：

1. 不能对boolean类型进行类型转换。
2. 不能把对象类型转换成不相关类的对象。
3. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
4. 转换过程中可能导致溢出或损失精度，例如：

1
2

int i = 128;
byte b = (byte) i;

此时输出b的值为 -128。

基础变量的包装类

Java 中每一个基础变量都有一个对应的包装类，对基础变量进行操作。

• Integer
• Short
• Long
• Float
• Double
• Boolean
• Byte
• Character

包装类可以对基本类型进行操作，如 Integer 类提供了将 String 变量转换为 int 变量的方法。

1
2

String str = "123";
int a = Integer.parseInt(str);

此时a的值为 123。

其余类型同理，具体可以通过快捷键在idea中查看各个包装类的方法，此处不再赘述。

前言：编码规范的重要性

什么是编码规范？

在讲编码规范的重要性之前，我们得先明白，什么叫做编码规范。在说代码规范之前，我们谈谈什么是路，鲁迅的《故乡》 原文结尾提到：“其实地上本没有路,走的人多了,也便成了路。”代码规范正如世上的路，代码原本只是为了实现某些功能，你可以任意的去写，但是大家慢慢的，习惯性的，在程序中都用同一种表示方法来实现某一个功能，于是就有了代码规范，然后所有的程序员都按照这个规范去写。比如秦始皇车九尺，书同文，就是为了做一个全国统一的规范，当时所有的修路工、读书人，都得按照这个规范去做。编码规范，就是做一个程序员之间统一的规范，方便互相之间的代码阅读及理解。

编码规范的重要性

这里采用举反例的方式来证明编码规范的重要性。

1

public class Demo{public static void main(String[] args){Scanner s=new Scanner(System.in);String ss=s.nextLine();if("exit".equalIgnoreCase(s)){System.out.println("开始退出程序...");System.exit;}}}

这样完成了一个简单的代码，你能轻松的对这段代码进行阅读吗？我甚至可以告诉你，这段代码有一处错误，你能第一时间发现吗？

但如果把代码按照以下格式编写，你就能很直观的看出问题所在。

1
2
3
4
5
6
7
8
9
10

public class Demo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = s.nextLine();
        if("exit".equalIgnoreCase(scanner)) {
            System.out.println("开始退出程序...");
            System.exit;
        }
    }
}

没错，在第五行 if 语句判断中，使用了 scanner 去判断是否输入了 exit ，这显然是错误的，应该使用 str 变量去进行判断。

正文：编码规范的标准

标识符的命名规范

概述

标识符的命名⼒求做到统⼀、达意和简洁。

统一

统⼀是指，对于同⼀个概念，在程序中⽤同⼀种表⽰⽅法，⽐如对于供应商，既可以⽤supplier，也可以⽤provider，但是我们只能选定⼀
个使⽤，⾄少在⼀个Java项⽬中保持统⼀。统⼀是作为重要的，如果对同⼀概念有不同的表⽰⽅法，会使代码混乱难以理解。即使不能取得
好的名称，但是只要统⼀，阅读起来也不会太困难，因为阅读者只要理解⼀次。

达意

达意是指，标识符能准确的表达出它所代表的意义，⽐如： newSupplier, OrderPaymentGatewayService等；⽽ supplier1, service2，idtts等则不是好的命名⽅式。准确有两成含义，⼀是正确，⼆是丰富。如果给⼀个代表供应商的变量起名是 order，显然没有正确表达。同样的，supplier1, 远没有targetSupplier意义丰富。

简洁

简洁是指，在统⼀和达意的前提下，⽤尽量少的标识符。如果不能达意，宁愿不要简洁。⽐如：theOrderNameOfTheTargetSupplierWhichIsTransfered 太长， transferedTargetSupplierOrderName则较好，但是transTgtSplOrdNm就不好了。省略元⾳的缩写⽅式不要使⽤，我们的英语往往还没有好到看得懂奇怪的缩写。

驼峰命名法

小驼峰命名法

小驼峰命名法指首字母小写，后续每一个单词首字母保持大写。例如 compareTwoObjects。

大驼峰命名法

大驼峰命名法指首字母大写， 后续每一个单词首字母保持大写。例如 PlayerLoginInListener。

英文与拼音

尽量使⽤通俗易懂的英⽂单词，如果不会可以向万能的度娘求助，实在不⾏则使⽤汉语拼⾳，避免拼⾳与英⽂混⽤。⽐如表⽰归档，⽤archive⽐
较好, ⽤pigeonhole则不好，⽤guiDang尚可接受。

包名

包名应当保持使用小写字母，并尽可能使用自己的域名来命名。例如我的域名是microhand.work，而我的网名是SanseYooyea，所以我的包名一般是work.microhand.sanseyooyea，此处域名应当反写。这么做的原因是为了避免包名重复，避免一些问题的产生。

类名

类名应当采用大驼峰命名法。

后缀

类名往往⽤不同的后缀表达额外的意思，如下表：

方法名

方法名应当采用小驼峰命名法

前缀

动词前缀往往表达特定的含义，如下表：

静态常量与枚举类变量

所有字母应保持大写，每个单词间用_分割，例如：ORDER_PAID_EVENT

普通变量

普通变量名应当采用小驼峰命名法

注释的规范

概述

• 注释宜少⽽精，不宜多⽽滥，更不能误导。

• 命名达意，结构清晰，类和⽅法等责任明确，往往不需要，或者只需要很少注释，就可以让⼈读懂；相反，代码混乱，再多的注释都

  不能弥补。所以，应当先在代码本⾝下功夫。

• 不能正确表达代码意义的注释，只会损害代码的可读性。

• 过于详细的注释，对显⽽易见的代码添加的注释，罗嗦的注释，还不如不写。

• 注释要和代码同步，过多的注释会成为开发的负担。

• 注释不是⽤来管理代码版本的，如果有代码不要了，直接删除，svn会有记录的，不要注释掉，否则以后没⼈知道那段注释掉的代码该

  不该删除。

Java doc

表明类、域和⽅法等的意义和⽤法等的注释，要以javadoc的⽅式来写。Java Doc是给类的使⽤者来看的，主要介绍是什么，怎么⽤等信
息。凡是类的使⽤者需要知道，都要⽤Java Doc 来写。⾮Java Doc的注释，往往是给代码的维护者看的，着重告述读者为什么这样写，如
何修改，注意什么问题等。

if 条件语句

if

这个形式的if语句基本形式为

1
2
3

if (expression) {
    //dosomething
}

这是最基本的if语句，if后跟一个括号，括号内写一个逻辑表达式，比如 3 + 5 == 8

而当 expression 为 true 时，将执行 {} 内语句。

1
2
3

if (1 + 1 == 2) {
    System.out.println("1 + 1 = 2");
}

执行该程序后，将输出 1 + 1 = 2。

if - else

这个形式的if语句基本形式为

1
2
3
4
5

if (expression) {
    //do something1
} else {
    //do something2
}

当 expression 为 true 时，将执行第一个大括号内的语句，否则执行第二个大括号内的语句，例如：

1
2
3
4
5

if (1 + 1 == 23) {
    System.out.println("1 + 1 = 23");
} else {
    System.out.println("1 + 1 ≠ 23");
}

这个程序运行后，将输出 1 + 1 ≠ 23

if - else if

这个形式的if语句基本形式为

1
2
3
4
5

if (expression1) {
    //do something1
} else if (expression2) {
    // do something2
}

当 expression1 为 true 时，将执行第一个大括号内的语句，否则判断 expression2，此时若 expression2 为 true 时，则执行第二个大括号内语句，否则不执行任何语句。例如：

1
2
3
4
5

if (1 + 1 == 23) {
    System.out.println("1 + 1 = 23");
} else if (1 + 1 == 2) {
    System.out.println("1 + 1 = 2");
}

这个程序运行后，将输出 1 + 1 = 2

if - else if - else

这个形式的if语句基本形式为

1
2
3
4
5
6
7

if (expression1) {
    //do something1
} else if (expression2) {
    // do something2
} else {
    // do something3
}

与 if - else if 类似，当 expression1 为 true 时，将执行第一个大括号内的语句，否则判断 expression2，此时若 expression2 为 true 时，则执行第二个大括号内语句，不同的是两者都为 false 时将执行第三个大括号内的语句。

1
2
3
4
5
6
7

if (1 + 1 == 3) {
    System.out.println("1 + 1 = 3");
} else if (1 + 1 == 4) {
    System.out.println("1 + 1 = 4");
} else {
    System.out.println("1 + 1 ≠ 3 且 1 + 1 ≠ 4");
}

这个程序运行后，将输出 1 + 1 ≠ 3 且 1 + 1 ≠ 4。

switch 条件语句

switch语句的基本语法为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

switch (expression) {
    case value1:
      //dosomething1
      //break;
    case value2:
      //dosomething2
      //break;
    //...
    case valuen:
      //dosomethingn
      //break;
    default:
      //dosomething
      //break;
}

expression部分为需要填写的表达式，而value则是值的意思。即如果 expression == valuen ，则程序会运行valuen冒号后的语句，直到break;

此处需要多注意的是，若没有break，程序在运行valuen的语句后，会继续运行valuen后续的值，比如value1没有break;则会继续执行value2中的语句，直到遇到break;或则执行完所有语句。而default的意思是，若判断完所有的值没有满足条件的，则会运行default中的语句。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

int height = new Scanner().nextInt();
switch (height) {
    case 1:
      System.out.println("有一米高！")
      break;
    case 2:
      System.out.println("有两米高！")
    case 3:
      System.out.println("有三米高！")
      break;
    default:
      System.out.println("比三米高！")
      break;
}

运行程序，输入1，则输出 有一米高！

输入2，则会输出

1
2

有两米高！
有三米高！

输入4，则会输出 比三米高！

for 循环语句

for 语句的基本语法为：

1
2
3

for (循环前语句;循环条件;循环末尾语句) {
    //dosomething
}

• 循环前语句

  循环前语句的意思就是，进入循环前，执行的语句。在其中定义的变量，其作用域仅局限于循环内。

• 循环条件

  循环条件用于判断是否执行循环，若不满足条件则会退出循环。

• 循环末尾语句

  循环末尾语句，当一次循环体内的 dosomething执行完以后，就会执行一次循环末尾语句。

例子：

1
2
3
4
5

int sum = 0;
for (int i = 1; i <= 100; i++) {
    sum += i;
}
System.out.println("1 + 2 + ... + 100 = " + sum);

最终输出结果就是 1 加到 100 的和。

while 循环语句

while

该类型while语句的基本语法如下：

1
2
3

while (expression) {
    //dosomething
}

当 expression 为 true 时，将会执行循环体中的语句//dosomething

例如

1
2
3
4
5
6
7

int sum = 0;
int i = 1;
while (i <= 100) {
    sum += i;
    i++;
}
System.out.println("1 + 2 + ... + 100 = " + sum);

最终输出结果就是 1 加到 100 的和。

do while

该类型的while语句基本语法如下：

1
2
3

do {
    //dosomething
} while (expression)

与上一类型不同的是，该类型 while 语句是先执行循环体内的内容，再判断一次 expression 是否需要执行下一次循环。

前言

为了更好的人机交互，程序需要接收用户传输的信息并进行处理，Java在控制台中采用了Scanner类以获取用户输入的信息。

Scanner英文直译为扫描器，从中也可以看出其作用。本篇博文将主要介绍Scanner类的常用用法以及特殊细节点并包含少量的底层原理。

需要自行查看底层代码时可翻阅之前我发布的博文查看如何快速查看申明，此处不再赘述。

用法

实例化

Constructs a new Scanner that produces values scanned from the specified input stream. Bytes from the stream are converted into characters using the underlying platform’s default charset.
Params:
source – An input stream to be scanned

1
2
3

public Scanner(InputStream source) {
    this(new InputStreamReader(source), WHITESPACE_PATTERN);
}

这是我们最常用的一种构造方法，我们在控制台中想要获取用户输入的信息，通常只需要

1

Scanner scanner = new Scanner(System.in);

System类中，in的修饰为static InputStream，因此可以直接通过类.变量方法进行调用，满足Scanner类构建需要的参数。

当然还有另外几种构建方式

1
2
3
4

public Scanner(InputStream source, String charsetName) {
        this(makeReadable(Objects.requireNonNull(source, "source"), toCharset(charsetName)),
             WHITESPACE_PATTERN);
    }

可以看出此处构造方法比上面一种多了一个参数 String charsetName，用于设置编码，编码种类较多，常用的有ANSI，UTF-8，GBK…以后会专门写一篇博文介绍。如果不填，默认使用UTF-8码。

方法及使用

ps.下文标题中的XXX包括了Line，Int，Double等等数据类型。

hasNextXXX

作用为判断下一行是否包含对应类型的值，若没有则返回 false，反之返回 true。

1
2
3
4
5
6

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    if (scanner.hasNextInt()) {
        System.out.println("下一行包含 int 数字");
    }
}

上面一段程序的左右就是检测下一行是否包含 int 型数字，若有则输出”下一行包含 int 数字”。

nextXXX

这个方法的作用为获取下一行对应类型的值，比如nextLine，则获取下一行的所有文字并存储为String变量。

1
2
3
4
5
6
7

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    if (scanner.hasNextLine()) {
        String inputString = scanner.nextLine();
        System.out.println("输入的文字为：" + inputString);
    }
}

这里有细节点需要注意，nextLine是字符串取到\n（\n为换行符）为止，包含\n，而nextInt则不包含\n，所以两者同时调用时，通常会出现一些奇怪的问题，比如，在控制台中输入：

1
2

123
test

而此时通过以下代码去读取：

1
2
3
4
5
6

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int inputInt = scanner,nextInt();
    String inputString = scanner.nextLine();
	System.out.println(inputInt + inputString);
}

输出的结果为：123

具体原因上面已经讲了，没懂可以再看一遍。

在ZuluJDK-的安装以及-IntellJ-IDEA-的安装与使用一文中，新建项目后，我写下了以下代码：

1
2
3
4
5

class GoodGoodStudy {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

现在开始一步步解析。

第一行代码

1

class GoodGoodStudy {}

这一段话的作用是声明了一个类，类名为GoodGoodStudy，类名必须与文件名一致。

class

在Java中，class是一个关键字，用于声明一个类。

GoodGoodStudy

GoodGoodStudy为类名，即类的名称，简称为类名。此处涉及了类的命名规范，将在下文详细介绍。

类的命名规范

1. 类名应当遵循大驼峰命名法，即类名中的每个单词首字母大写，以方便阅读。
2. 类名应当体现该类的意义，如程序主入口命名为项目名或Main比较恰当。
3. 如果是接口，则应当在类名前加上大写的I。（接口在后续教程中会讲到，此处只需留有一定印象）。

第二行代码

1

public static void main(String[] args) {}

public

关于public，实际上可以引出Java中四个权限修饰符——private，protected，default，public，这四个权限修饰符同样都是关键字。其中的区别可以看下图。

static

此处static同样是关键字，在此处的作用是将main方法声明为静态方法。

静态方法的作用是，哪怕不实例化一个类的对象，也可以直接调用该类的静态方法。例如：

1
2
3
4
5

class Demo {
    public static void printHello() {
        System.out.println("Hello！");
    }
}

而在其他类调用时，可以这么调用：

1
2
3
4
5

class TestPrintHello {
    public static void main(String[] args) {
        Demo.printHello();
    }
}

但是在静态方法中不能调用非静态方法或非静态变量。

void

void同样是关键字，用于声明被声明的方法没有返回值。即不会返回任何值。

main

main不是关键字，参数为String[] args的main函数为程序主入口，一个类中只有一个入口。

程序运行时将从main入口开始。

String[] args

String[] args 意思是申明一个名为args的数组，在main函数处，args是该函数的一个参数，当运行程序时，可以附带参数。

在idea中编译运行时，可以点击图中位置而后点击编辑运行环境(Edit Configurations…)，参数即可在Build and run -> Program arguments中输入。

如果选择使用cmd运行jar文件，可以使用如下命令:

1

java -jar xxx.jar arg1 arg2 arg3

此时main方法中的args[1] = “arg1”, args[2] = “arg2”, args[3] = “arg3”。

第三行代码

System.out.println();

System是JDK中自带的一个类，位于java.lang包下，而out则是System类中的一个方法，其doc与声明如下：

The “standard” output stream. This stream is already open and ready to accept output data. Typically this stream corresponds to display output or another output destination specified by the host environment or user.
For simple stand-alone Java applications, a typical way to write a line of output data is:
System.out.println(data)

See the println methods in class PrintStream.
See Also:
PrintStream.println(), PrintStream.println(boolean), PrintStream.println(char), PrintStream.println(char[]), PrintStream.println(double), PrintStream.println(float), PrintStream.println(int), PrintStream.println(long), PrintStream.println(Object), PrintStream.println(String)

1

public final static PrintStream out = null;

其作用是获取一个类型为PrintStream的out对象，而PrintStream类中包含println方法，

java中调用方法有两种方式，一是申明为static的方法可直接通过类名.方法调用，二是通过实例化一个类的对象，再使用对象.方法

println作用是打印所传的参数，并且换行。

Prints a String and then terminate the line. This method behaves as though it invokes print(String) and then println().
Params:
x – The String to be printed.

1
2
3
4
5
6

public void println(String x) {
	synchronized (this) {
		print(x);
        newLine();
    }
}

有兴趣的可以对底层代码进行更进一步的研究，此处不再赘述。

易发生问题

刚安装完成但无法新建项目

这个问题是我于昨天才碰到的，尝试过重启电脑，重装IDEA，都不能解决，但重装Zulu JDK后成功解决，原因暂时未知。

将Java Class新建于 src 包外

这个问题有多个人发生，将Java Class新建在了src包外面，其实按照我之前发的教程截图一步步走是不会这样的😣

这边先解释一下src是什么意思，src是 source code 的缩写，source code 意思是源代码，所以按道理你应该将你的源代码放在src包内。

怎么保存写好的代码

IDEA是现代高级编程工具，有自动保存功能，直接关闭就可以保存！

怎么打开写好的项目

点击idea的启动器，而不是去双击打开.java文件！这样打开是处于light edit模式！

关于付费版IDEA

付费版IDEA有两种方式可以长期免费使用。

1. 使用 edu 邮箱去JetBrains官网申请，需要经过约莫几天至半个月的审核。部分edu邮箱可能被判无法使用，需要使用学信网学籍辅助证明。
2. 使用IDEA的破解插件，无限期重置试用时间，该教程博客不详细写了，放个链接自己研究

使用细节

自动补全

活用自动补全能提高代码开发效率，如想使用for循环时，只需要输入for，而后按 回车键 ，就能自动生成for循环的基本结构。

快速导包

今天有许多人写代码时用到了Scanner，但写下去以后显示报错，这是因为没有import导包的原因，这里讲个快捷键用于快速导包：

1

Scanner scanner = new Scanner(System.in);

此处报错时将鼠标点击Scanner，然后按下 Alt + Enter(回车键) 即可快速导包。

查看调用与声明

按住 Ctrl，再点击你想查看的类/方法/属性，或则点击你想查看的类/方法/属性，按下 Ctrl + B ，即可查看其声明处或调用处。

更改包名/类名/方法名/属性名

IDEA含有一个快捷键更改项目中所有用到包/类/方法/属性的地方，例如你想更改一个方法名，点击那个方法，然后使用 Shift + F6 即可进行更改，同时项目中所有用到该函数的代码中也会一同更改。

快速运行

运行不用每次都点击菜单上的Run -> Run，可以尝试快捷键Shift + F10

断点调试

点击左侧非数字处即可打上断点，Debug快捷键为Shift + F9，开启调试模式后可按快捷键 F8 进行单步调试。

调试过程中，可以看到运行过的地方的每一个变量值。

类的概念理解

类是面向对象编程中一个极其重要的核心概念，可以说面向对象编程的一切操作，都是围绕类进行的。

所以想学好面向对象编程，一定要先理解类的概念。

从中文词语上理解类

1.许多相似或相同事物的综合：种～。分～。同～。

2.用于性质或特征相同或相似的事物：分成几～。两～性质的问题。

3.类似：～人猿。～新星。画虎不成反～狗。

4.姓。

上文来自于百度百科中对类的解释，不难得见类是指有相似处的一些物品。

使用该意义的类进行组词，比如：鸟类，鱼类等等，这些词语都是对一个群体的抽象概括。

而在面向对象编程中，这些类可以翻译成Bird类，Fish类，也就是类的名称为Bird，Fish。

大白话来讲就是这么个意思，如果想看更加精准更加科学的解释可以前往百度百科查看。

对象/实例

对象是类中的一个概念，比如人类中有一个名为拜登的人类，那这个拜登，就是人类的一个实例，也就是一个对象。

属性

每个对象都有一个或多个属性，比如上述所提到的拜登实例，他拥有一个“名字”属性，该属性属性值为拜登。

方法

每个对象都可以有一系列的动作，同样拿拜登实例举例，拜登可以当众拉屎，那当众拉屎就是他的一个动作，在Java中称为方法。

1

public void takeShitInPublic() {}

类的基本特性

封装

在类的概念清楚之后，其实封装也很好理解。

好比如鸟类，不管是什么鸟，它都有一个名字，所以鸟类下可以有一个属性名为name的属性，在 Java 中表示如下：

1
2
3

class Bird {
    private String name;
}    

而鸟也有能飞或者不能飞两种，所以需要一个flyAble属性，

1
2
3
4

class Bird {
    private String name;
    private boolean flyAble;
}

因为申明为private，类中需要向外界提供public的getter，并且需要一个构造方法（构造方法就是当实例化该类的一个对象时调用的方法）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class Bird {
    private String name;
    private boolean flyAble;
    
    public String getName() {
        return name;
    }
    
    public boolean getFlyAble() {
        return flyAble;
    }
    
    public Bird(String name, boolean flyAble) {
        this.name = name;
        this.flyAble = flyAble;
    }
}

而如果他能飞，我们需要给他一个飞这个动作的实现，

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

class Bird {
    private String name;
    private boolean flyAble;
    
    public String getName() {
        return name;
    }
    
    public boolean getFlyAble() {
        return flyAble;
    }
    
    public Bird(String name, boolean flyAble) {
        this.name = name;
        this.flyAble = flyAble;
    }
    
    public void fly() {
        if (flyable) {
            System.out.println("起飞！");
        } else {
            System.out.println("我不能飞！www！");
        }
    }
}

而外界代码想要调用Bird类时，都必须先实例化一个Bird类的对象：

1
2
3
4
5
6

class Demo {
    public static void main(String[] args) {
        Bird e = new Bird("鹅", false);
        e.fly();
    }
}

当上述过程完善后，形成了一个较为完整的类。

而外界想要取得Bird类一个对象的name和flyAble的值，或是想要该对象fly时，则只能通过实例化Bird类的对象进行get，而不是直接使用Bird.name获取或是Bird.fly()飞行，防止外部的随意调用产生问题。

继承

先抛开继承这个词不谈，我们接续上文关于类的理解，从这个方向来理解继承。

生物圈里有三个大类，一是动物类，二是微生物类，三是植物类。

而动物类又包含许多种类的动物，如鱼类，鸟类。即鱼类和鸟类都属于动物类。

而在面向对象编程中，我们把这个从属关系，叫做继承关系。

比如在封装中提到的鸟类与鹅，如果我们新建一个鹅类，他需要继承自鸟类。

1

class Goose extends Bird {}

此时Goose类就拥有了Bird类有的所有属性和方法，即 name , flyAble , fly()

但是鹅是会游泳的，所以这里我们需要另写一个方法 swim()

1
2
3
4
5

class Goose extends Bird {
    public void swim() {
        System.out.println("开始冲浪！(bushi)");
    }
}

此时鹅继承了鸟类，但是也有自己独立的动作。

1
2
3
4
5
6
7

class Demo {
    public static void main(String[] args) {
        Goose goose = new Goose("鹅", false);
        goose.fly();
        goose.swim();
    }
}

同样的，更多解释前往百度百科查看。

抽象

同样的接续鸟类的例子，我们都知道不同鸟之间飞行的动作可能不一样，所以如果都写在鸟类的fly方法中，会导致代码非常臃肿庞大。

此时有一个方法，就是让继承自鸟类的其余类自己去实现不同的方法，这就是抽象，而此时，鸟类就是一个抽象类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

abstract class Bird {
    private String name;
    private boolean flyAble;
    
    public String getName() {
        return name;
    }
    
    public boolean getFlyAble() {
        return flyAble;
    }
    
    public Bird(String name, boolean flyAble) {
        this.name = name;
        this.flyAble = flyAble;
    }
}

其中属性、函数等都可以一样写在里面。但是继承的类，必须同样含有这些方法。

一、JDK的安装

此处JDK推荐使用Azul Zulu JDK 8点击前往其官网下载。

下载完成后双击安装出现如下界面：

该界面点Next，

选择安装路径后点Next，此处不推荐安装在C盘，同时路径最好不要包含中文。

该界面点击Install安装。

二、编写工具IDEA的安装

网络上常见的java编写ide（即集成编写环境）有两种，一是eclipse，二是IntellJ IDEA，此处更推荐IDEA，IDEA是目前社区内最受好评的编写环境。故此处选择IDEA安装，如果选择eclipse，需要自行配置JDK环境，配置教程自行百度，此处不另附。

（此处IDEA安装为社区免费版，付费版可通过使用edu邮箱进行申请，或则通过插件破解以免费使用，具体步骤另附（咕咕咕））

Windows用户点击前往下载IDEA社区版

苹果MacOS用户点击前往下载IDEA社区版

下载完成后双击安装出现如下界面：

点击Next

选择安装路径后点击Next，此处不推荐安装在C盘，同时路径最好不要包含中文。

• 第一个意思是快捷方式

• 第二个是加到开始菜单栏里

• 第三个最好全√就对了

• 右边是设置环境变量，需重启生效，√不√看你心情

直接点Install。

三、新建项目

点击New Project

SDK一般会自动检测出来，若没检测需要手动选择第一步中安装的JDK。

这里不需要勾选，直接点击Next

Next

先在Project location中新建好你存项目的文件夹并选中，然后Project name填写你的项目名称，例如Test01,Demo01,Homework01等等。

请记住此处项目的文件夹可多次使用，即该文件夹中可存放你的多个项目。推荐将你本学期的所有作业放于该文件夹中，这是一个良好的习惯。

选择完毕后点击Finish。

进入该页面后，左侧为你的文件夹树，选中src右键New -> Java Class点击

出现该界面后Name需填写你的类名。此处插一句嘴，编码规范中要求类名首字母保持大写，若涉及多个单词按如下格式编写，例：GoodGoodStudy。

在该页面中编写你的java程序，例子如下：

1
2
3
4
5

public class GoodGoodStudy {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

编写完成后点击上方Run -> Run，

此处即为你的程序运行结果！至此参照给出的例子你已经迈出了Java学习的第一步，HelloWorld！

四、插件的推荐及安装

接续上一节的画面，点击左上方的File -> Settings

左侧点击Plugins

上方选择Marketplace，然后在下方搜索栏中可以搜索你想要的插件，插件安装点击其后的Install后等待安装完成即可。

此处推荐几个插件。

1.Chineses(Simplified) Language Pack，IDEA官方中文汉化包，对英文看不懂的同学友好度极高。安装后需重启

2.Material Theme UI，主题插件，可以让你的编写工具颜值更高（安装以后在Settings中查找Material Theme UI进行设置，推荐Deep Ocean）

3.Background Image Plus + ，背景图片插件，选择你的背景图片文件夹，可以让你的编写工具呈现背景图片，写累了还能看看美图！可设置每隔几分钟就更换一张图片。

4.Rainbow Brackets，彩虹括号，让你的括号更加清楚显眼，防止因为括号太多而对错了。

5.Codota AI Autocomplete for Java and JavaScript，智能AI代码补全，让你的编码更加轻松容易！

6.CodeGlance3，显示你的代码缩略图，使结构更加清晰！

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1

$ hexo new "My New Post"

More info: Writing

Run server

1

$ hexo server

More info: Server

Generate static files

1

$ hexo generate

More info: Generating

Deploy to remote sites

1

$ hexo deploy

More info: Deployment