fix(guide): simplify directory structure

This commit is contained in:
Mrugesh Mohapatra
2018-10-16 21:26:13 +05:30
parent f989c28c52
commit da0df12ab7
35752 changed files with 0 additions and 317652 deletions

View File

@ -0,0 +1,34 @@
---
title: Exceptions in Java
localeTitle: Java中的例外情况
---
## 什么是例外?
异常是一个不需要的或意外的事件,它发生在程序执行期间,即在运行时,会破坏程序指令的正常流程。
## 错误与异常
错误:错误表示合理的应用程序不应该尝试捕获的严重问题。 例外:异常表示合理的应用程序可能尝试捕获的条件。
## 异常层次结构
所有异常和错误类型都是Throwable类的子类它是层次结构的基类。一个分支以Exception为首。此类用于用户程序应捕获的异常条件。 NullPointerException是此类异常的示例。另一个分支Java运行时系统JVM使用Error来指示与运行时环境本身JRE有关的错误。 StackOverflowError是此类错误的一个示例。
## 如何使用try-catch子句
```
try {
// block of code to monitor for errors
// the code you think can raise an exception
}
catch (ExceptionType1 exOb) {
// exception handler for ExceptionType1
}
catch (ExceptionType2 exOb) {
// exception handler for ExceptionType2
}
// optional
finally {
// block of code to be executed after try block ends
}
```

View File

@ -0,0 +1,26 @@
---
title: Abstract Classes in Java
localeTitle: Java中的抽象类
---
让我们讨论抽象类。在深入学习本教程之前,最好先了解一下类的概念 和继承。
抽象类是可以子类化(即扩展)但不能实例化的类。您可以将它们视为接口的**类版本** ,或者作为附加到方法的实际代码的接口。
请考虑以下示例来理解抽象类: 您有一个类Vehicle它定义机器应具有的某些基本功能方法和某些组件对象变量以归类为车辆。您无法创建Vehicle的对象因为车辆本身就是一个抽象概念。但是您可以扩展车辆类的功能以创建汽车或摩托车。
\`\`\`java 抽象类车辆 { //用于声明no的变量。在车辆中的车轮 私人车轮;
//变量用于定义所用电机的类型 私人电机;
//一个只声明但不定义开头的抽象方法 //功能因为每辆车都使用不同的启动机制 abstract void start; }
公共类汽车扩展车辆 { ... }
公共类摩托车扩展车辆 { ... }
```
You cannot create an object of Vehicle class anywhere in your program. You can however, extend the abstract vehicle class and create objects of the child classes;
```
java的 车辆newVehicle = new Vehicle; //无效 车辆车=新车(); //有效 车辆mBike =新摩托车(); //有效
Car carObj = new Car; //有效 摩托车mBikeObj =新摩托车(); //有效 \`\`\`

View File

@ -0,0 +1,123 @@
---
title: Access Modifiers
localeTitle: 访问修饰符
---
# 访问修饰符
你有没有想过定义人们如何访问你的一些房产?你不希望任何人使用你的内衣。但是,亲密的朋友和亲戚可以使用你的毛衣,也许你的车。
与您设置访问级别的方式类似Java也控制访问权限。您希望根据要访问它们的其他类来定义变量方法和类的访问级别。
Java提供了4级访问修饰符。这意味着您可以通过4种方式修改对变量方法或类的访问。这4种方式是私有的公共的受保护的和默认的。
这些访问修饰符可以应用于字段,方法和类(类是一种特殊情况,我们将在本文末尾查看它们)。以下是每个`Access Modifier``Access Levels`的快速概述1
#### 访问修饰符表参考:
![访问修饰符表](https://i.imgur.com/zoMspyn.png)
#### 私人访问修改器
允许仅在创建变量或方法的类中访问它。除了创建变量或方法的类之外没有其他类可以访问它。这与您的内脏非常相似。它们仅供业主使用。要将变量或方法设为私有只需在变量或方法类型之前附加private关键字即可。 让我们在编码示例中使用private。如果一家银行想要为其贷款提供10的利率那么它将确保利率变量让我们假设`int int_rate;` )保持私有,以便其他类别不会尝试访问并更改它。 例如;
`private String name;`
上面的示例创建了一个名为name的变量并确保它只能在创建它的类中访问。
方法的另一个例子是 `java private void setAge(){ System.out.println("Set Age"); }` 上面的示例确保方法setAge只能在创建它的类中访问而不能在其他任何地方访问。
#### 公共访问修饰符
公共访问修饰符与私有访问修饰符直接相反。类方法或变量可以声明为public这意味着可以从任何类访问它。公共访问修饰符可以比作公立学校任何人都可以寻求入学和录取。
可以随时从任何其他类访问公共类,方法或变量。
例如要将类声明为public您只需要
```java
public class Animal{
}
```
因此Animal类可以被任何其他类访问。
```java
public int age;
public int getAge(){
}
```
以上是将变量和方法指定为公共的方法。
#### 默认访问修饰符
默认访问修饰符与所有其他访问修饰符的不同之处在于它没有关键字。要使用默认访问修饰符,您只需使用其他访问修饰符,这只是意味着您使用的是默认访问修饰符。
例如,要使用类的默认访问修饰符,请使用
```java
class Bird{
}
```
这基本上意味着您正在使用默认访问修饰符。默认访问修饰符允许同一包中的其他类可以访问变量,方法或类。包是文件目录中相关类的集合。有关包的更多信息,请查看包中的部分。
声明为使用默认访问修饰符的任何变量,方法或类都不能被声明它的包之外的任何其他类访问。
```java
int age;
void setNewAge(){
}
```
以上是对变量或方法使用默认访问修饰符的一些方法。 别忘了默认访问修饰符没有关键字。缺少其他3个访问修饰符意味着您正在使用默认访问修饰符。
#### 受保护的访问修饰符
受保护的访问修饰符与默认访问修饰符密切相关。受保护的访问修饰符具有默认访问修饰符的属性,但稍有改进。
变量和方法是唯一使用受保护的访问修饰符的方法。稍微改进的是声明变量或方法的类包之外的类可以访问所述变量或方法。但是如果它继承自Class则这是可能的。
来自另一个可以看到受保护变量或方法的包的类必须扩展创建变量或方法的类。
注意,如果没有继承的优点,默认访问修饰符与受保护的访问修饰符具有完全相同的访问权限。
使用受保护的访问修饰符的示例如下所示:
```java
protected int age;
protected String getName(){
return "My Name is You";
}
```
#### 访问类的修饰符
默认情况下类只能有2个修饰符
* 上市
* 无修饰符(默认修饰符)
那么这意味着类永远不能设置为`private``protected`
这是合乎逻辑的,你为什么要私人上课?没有其他类可以使用它。但有时候,你可以将一个类嵌入到另一个类中。这些特殊的类, `inner classes` 可以设置为private或protected以便只有它的周围类可以访问它
```java
public class Car {
private String brand;
private Engine engine;
// ...
private class Engine {
// ...
}
}
```
在上面的示例中,只有`Car`类可以使用`Engine`类。在某些情况下,这可能很有用。
其他类永远不能设置为`protected``private` ,因为它没有任何意义。 `protected`访问修饰符用于使`package-private`但具有子类可访问的选项。在java中没有诸如“子包”或“包继承”之类的概念。
### 来源
[1.关于Access Modifiers的Oracle文档](https://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html "Oracle Docs")

View File

@ -0,0 +1,23 @@
---
title: ArrayList
localeTitle: 数组列表
---
# 数组列表
ArrayList是_Collection框架的一部分_ 。
_Collection框架_包含所有可以包含一组值的接口和类类似于[数组](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html) )。 **ArrayList**是此层次结构中的一个类称为_**Collection对象**_ 。它实现了_List_接口后者又实现了_Collection_接口。可以在`java.util`包中找到此_Collection_接口。您需要导入此包。
ArrayList是一个用于创建动态数组的类。它比常规数组慢但允许大量操作。它可以初始化为具有特定大小或者默认大小为10个单位。
`java ArrayList<String> names = new ArrayList<>(); ArrayList<Integer> ages = new ArrayList<>(5);`
在上面的代码片段中角度breacket `<>`采用通用数据类型作为参数指定ArrayList中元素的数据类型。第一个ArrayList `names`被指定为包含_String_元素。因此只允许包含String元素。它的大小未指定因此它的默认大小为10.第二个ArrayList `ages`指定它只保存整数。但是ArrayList不能保存基元它只保存对象。因此为了使它存储整数浮点数等我们可以使用包装类。 `names`的指定大小为5。
由于ArrayList实现了_List_ 因此可以使用以下语法创建ArrayList `java List<Integer> students = new ArrayList<>();`
ArrayList是动态的这意味着它会在需要时增大如果从中删除元素它的大小也会缩小。这使得它比普通数组更好用。
ArrayList允许我们随机访问元素。 ArrayList在很多方面类似于_Vector_ 。但它比矢量更快。需要注意的主要事项是 - 矢量比数组快但ArrayLists不是。
因此,当选择两者之间时 - 如果速度至关重要则应考虑Vector否则ArrayLists在存储大量元素和有效访问时更好。

View File

@ -0,0 +1,186 @@
---
title: Arrays
localeTitle: 数组
---
# 排列
Array是在顺序存储器地址中保存的具有相似数据类型允许数据类型形式的基元和引用的值或对象的集合。 Array用于存储类似数据类型的集合。 数组总是从索引0开始并实例化为一定数量的索引。 数组中的所有变量必须是同一类型,在实例化时声明。
**句法:**
```java
dataType[] arrayName; // preferred way
```
这里, `java datatype[]`描述了在它之后声明的所有变量将被实例化为指定数据类型的数组。因此,如果我们想要实例化更多类似数据类型的数组,我们只需要在指定的`java arrayName`之后添加它们(不要忘记仅通过逗号分隔它们)。下一节将给出一个例子以供参考。
```java
dataType arrayName[]; // works but not preferred way
```
这里, `java datatype`仅描述了属于该数据类型后所声明的变量。此外,变量名后面的`java []`描述变量是指定数据类型的数组(而不仅仅是该数据类型的值或对象)。因此,如果我们想要实例化更多相似数据类型的数组,我们将在已经指定的数组之后添加变量名称,用逗号分隔,每次我们必须在变量名后添加`java []` ,否则变量将是实例化为普通的值存储变量(不是数组)。为了更好地理解,下一节将给出一个示例。
## 上述语法的代码片段:
```java
double[] list1, list2; // preferred way
```
上面的代码片段实例化了两个双重类型名称list1和list2的数组。
```java
double list1[], list2; // works but not preferred way
```
上面的代码片段是一个数组类型的数组double名为list1数据类型为double的简单变量名为list2不要与名称**list2**混淆。变量名称与变量类型无关)。
注意:样式`double list[]`不是首选因为它来自C / C ++语言并且在Java中被采用以适应C / C ++程序员。另外它更具可读性:你可以读到它是一个“双数组命名列表”而不是“一个双重调用列表是一个数组”
## 创建数组:
```java
dataType[] arrayName = new dataType[arraySize];
```
## 上述语法的代码片段:
```java
double[] List = new double[10];
```
## 另一种创建数组的方法:
```java
dataType[] arrayName = {value_0, value_1, ..., value_k};
```
## 上述语法的代码片段:
```java
double[] list = {1, 2, 3, 4};
The code above is equivalent to:
double[] list = new double[4];
*IMPORTANT NOTE: Please note the difference between the types of brackets
that are used to represent arrays in two different ways.
```
## 访问数组:
```java
arrayName[index]; // gives you the value at the specified index
```
## 上述语法的代码片段:
```java
System.out.println(list[1]);
```
输出:
```
2.0
```
## 修改数组:
```java
arrayName[index] = value;
```
注意:初始化后,您无法更改阵列的大小或类型。 注意:您可以像这样重置数组
```java
arrayName = new dataType[] {value1, value2, value3};
```
## 数组大小:
可以使用“length属性”找到数组中的元素数量。这里应该注意 `java length`是每个数组的**属性** ,即存储变量长度的变量名。不能将它与数组**方法**混淆因为该名称与String类对应的`java length()`方法相同。
```java
int[] a = {4, 5, 6, 7, 8}; // declare array
System.out.println(a.length); //prints 5
```
## 上述语法的代码片段:
```java
list[1] = 3; // now, if you access the array like above, it will output 3 rather than 2
```
_代码示例_
```java
int[] a = {4, 5, 6, 7, 8}; // declare array
for (int i = 0; i < a.length; i++){ // loop goes through each index
System.out.println(a[i]); // prints the array
}
```
输出:
```java
4
5
6
7
8
```
### 多维数组
二维数组2D数组可以被认为是具有行和列的表。虽然这种表示只是一种可视化阵列的方法可以更好地解决问题。这些值实际上仅存储在顺序存储器地址中。
```java
int M = 5;
int N = 5;
double[][] a = new double [M][N]; //M = rows N = columns
for(int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
//Do something here at index
}
}
```
这个循环将执行M ^ N次并将构建此
\[0 | 1 | 2 | 3 | 4\]
\[0 | 1 | 2 | 3 | 4\]
\[0 | 1 | 2 | 3 | 4\]
\[0 | 1 | 2 | 3 | 4\]
\[0 | 1 | 2 | 3 | 4\]
类似地也可以制作3D阵列。它可以被视为长方体而不是矩形如上所示被分成较小的立方体每个立方体存储一些值。它可以初始化如下
```java
int a=2, b=3, c=4;
int[][][] a=new int[a][b][c];
```
以类似的方式,可以是他/她希望的多个维度的阵列但是难以以特定方式可视化多于3个维度的阵列。
### 锯齿状阵列
锯齿状数组是多维数组,具有一定数量的行但具有不同数量的列。锯齿状数组用于节省阵列的内存使用。这是一个代码示例:
```java
int[][] array = new int[5][]; //initialize a 2D array with 5 rows
array[0] = new int[1]; //creates 1 column for first row
array[1] = new int[2]; //creates 2 columns for second row
array[2] = new int[5]; //creates 5 columns for third row
array[3] = new int[5]; //creates 5 columns for fourth row
array[4] = new int[5]; //creates 5 columns for fifth row
```
输出:
\[0\]
\[0 | 1\]
\[0 | 1 | 2 | 3 | 4\]
\[0 | 1 | 2 | 3 | 4\]
\[0 | 1 | 2 | 3 | 4\]
#### 更多信息:
* 来源: [Java Arrays](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html)

View File

@ -0,0 +1,61 @@
---
title: bitwise operator example
localeTitle: 按位运算符示例
---
# 按位运算符
## 真相表
![truth table](https://4.bp.blogspot.com/-0KPDI41veH0/V-OtObm_UWI/AAAAAAAAAso/CkTS0zUMGKIjlE3gUD0fMhmp-B0zcfBmACLcB/s1600/Bitwise-truthtable-Javaform.jpg "真相表")
按位运算符与逻辑运算符类似,不同之处在于它们的工作规模较小 - 数据的二进制表示。任何数据都可以转换为二进制等价物。虽然二元运算符在二进制级别工作,但它们仅在正常的十进制值之间运行。
## 按位运算符的类型
### 按位OR
按位OR是二元运算符对两个操作数进行操作。它用|表示。 |运算符比较两个操作数的相应位。如果其中一个位为1则给出1.如果不是则给出0。
### 按位AND
按位AND是二元运算符对两个操作数进行操作。用表示。 运算符比较两个操作数的相应位。如果两个位都是1则它给出1.如果其中一个位不是1则它给出0。
### 按位补充
按位补码是一元运算符(仅适用于一个操作数)。它用〜表示。 〜运算符反转位模式。它使每0到1每1到0。
### 按位异或
Bitwise XOR是一个二元运算符在两个操作数上运行。它用^表示。 ^运算符比较两个操作数的相应位。如果相应的位不同则给出1.如果相应的位相同则给出0。
### 左移
左移位运算符<<将位模式向左移位一定数量的指定位并且零位移位到低位位置
### 右转
右移位运算符>>将位模式向右移位一定数量的指定位。如果该数字是2的补码有符号数则符号位移入高位位置。
### 无符号右移
无符号右移运算符>>>将零移至最左侧位置。
### 示例按位运算符:
```java
int a = 60; /* 60 = 0011 1100 represents 60 in binary*/
int b = 13; /* 13 = 0000 1101 */
int c = 0;
c = a & b; /* 12 = 0000 1100 */
c = a | b; /* 61 = 0011 1101 */
c = a ^ b; /* 49 = 0011 0001 */
c = ~a; /*-61 = 1100 0011 :Invert all bits */
// shift operators : zeros are shifted in to replace the discarded bits
c = a << 2; /* 240 = 1111 0000 : Shift left 2 bits*/
c = a >> 2; /* 15 = 1111 */
c = a >>> 2; /* 15 = 0000 1111 : Zero fill right shift*/
```
**有关更多信息:请** [单击此处](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/op3.html)

View File

@ -0,0 +1,44 @@
---
title: Basic Operations
localeTitle: 基本操作
---
# 基本操作
Java支持对变量进行以下操作
* **算术** `Addition (+)` `Subtraction (-)` `Multiplication (*)` `Division (/)` `Modulus (%)` `Increment (++)` `Decrement (--)`
* **字符串连接** `+`可用于字符串连接,但减法`-`在字符串上不是有效操作。
* **关系** `Equal to (==)` `Not Equal to (!=)` `Greater than (>)` `Less than (<)` `Greater than or equal to (>=)` `Less than or equal to (<=)`
* **按位** `Bitwise And (&)` `Bitwise Or (|)` `Bitwise XOR (^)` `Bitwise Compliment (~)` `Zero fill right shift (>>>)` `Bitwise Compliment (~)` `Left shift (<<)` `Right Shift (>>)` `Zero fill right shift (>>>)`
* **逻辑** `Logical And (&&)` `Logical Or (||)` `Logical Not (!)`
* **赋值** `=` `+=` `-=` `*=` `/=` `%=` `<<=` `>>=` `&=` `^=` `|=`
* **其他** `Conditional/Ternary(?:)` `instanceof`
虽然大多数操作都是不言自明的,但条件(三元)算子的工作原理如下:
`expression that results in boolean output ? return this value if true : return this value if false;`
例: 真实条件:
```java
int x = 10;
int y = (x == 10) ? 5 : 9; // y will equal 5 since the expression x == 10 evaluates to true
```
错误条件:
```java
int x = 25;
int y = (x == 10) ? 5 : 9; // y will equal 9 since the expression x == 10 evaluates to false
```
运算符的实例用于类型检查。它可用于测试对象是否是类,子类或接口的实例。一般格式 - _类/子类/接口的对象**实例**_
这是一个程序来说明instanecof运算符 \`\`\`的Java Person obj1 = new Person; 人obj2 =新男孩();
```
// As obj is of type person, it is not an
// instance of Boy or interface
System.out.println("obj1 instanceof Person: " + (obj1 instanceof Person)); /*it returns true since obj1 is an instance of person */
```
\`\`\`

View File

@ -0,0 +1,25 @@
---
title: Build Tools
localeTitle: 构建工具
---
# 构建工具
Java构建工具允许您自定义构建以执行诸如指定需要包含在jar中的文件从Internet添加依赖项以及自动执行测试或github提交等任务的操作。构建工具还可以轻松地模块化您的项目。流行的构建工具包括[Gradle](https://gradle.org/)和[Maven](https://maven.apache.org/)
## 摇篮
Gradle构建脚本可以用Groovy或Kotlin编写并且可以高度自定义。大多数项目使用Gradle包装器允许它们在任何系统上构建即使没有安装Gradle也是如此。 Gradle是Android开发的推荐构建工具。
## Maven的
Maven构建文件是用XML编写的。与Gradle一样许多插件都是为Maven编写的用于自定义构建但Maven不是可自定义的因为您无法直接与Maven API交互。
### 更多信息:
https://gradle.org/
https://en.wikipedia.org/wiki/Gradle
https://maven.apache.org/what-is-maven.html
https://en.wikipedia.org/wiki/Apache\_Maven

View File

@ -0,0 +1,14 @@
---
title: Built-In Functions
localeTitle: 内置功能
---
# 内置功能
Java还有许多内置或预定义的函数它们通常存储在java.lang和java.io包中 它们会在BlueJ等编辑器中自动导入或者可以使用以下语法导入 -
```java
import java.lang.*;
import java.io.*;
```
这些功能包括使其他长期和艰巨任务更容易完成的功能。

View File

@ -0,0 +1,85 @@
---
title: Classes and Objects
localeTitle: 类和对象
---
# 类和对象
类是变量和操作的组。一个类可以有变量,方法(或函数)和构造函数(或者用于启动的方法,稍后会有更多内容!)。
类可以包含以下任何变量类型。
* 类变量这些是使用static关键字在任何方法之外在类定义中声明的变量。类变量在类的所有实例之间共享。类变量也称为静态变量它们在编译类时只初始化一次因此只有一个副本可用于所有实例。
* 实例变量:与类变量的不同之处在于,实例变量在类构造函数中初始化,并且不在所有对象之间共享。在实例化时,创建实例变量的新副本。
```java
public class Example {
private static int myVar = 1; // Class Variable
private int mySecondVar; // Instance Variable
Example(int mySecondVar) {
this.mySecondVar = mySecondVar; // An instance variable must be initialized inside the constructor
```
`Class`视为创建具体事物的蓝图。一个`Class`告诉你如何`instantiated`所述类的`object`的'what'和'how'。从本质上讲,它定义了以下情况下汽车的`properties` (比如颜色,发动机容量)和`behavior` (停止,加速,换档,鸣喇叭等)。
对象是类的_实例_ 。所有对象都是某个类的实例。想象一个类是一个“模板”每个Object都会从中复制。在创建Object时它基本上会在类的蓝图上创建一个新对象。现在让我们在一小段代码中看一下
```java
// Car class
public class Car {
// car name
private String name;
// car manufacturer name
private String manufacturerName;
// constructor 1
public Car() {
}
// constructor 2
public Car(String name, String man) {
this.name = name;
this.manufacturerName = man;
}
// getter name method
public String getName() {
return name;
}
// getter manufacture method
public String getManufacturerName() {
return manufacturerName;
}
//setter name method
public void setName(String name){
this.name = name;
}
//setter manufacture method
public void setManufacture(String man){
this.manufacturerName = man;
}
}
// sample code
Car modelS = new Car("Model S","Tesla");
// prints Tesla Model S
System.out.println("Full Car Model S= " + modelS.getManufacturerName() + " : " + modelS.getName());
Car modelX = new Car();
modelX.setName("Model X");
modelX.setManufacture("BMW");
// prints Tesla Model X
System.out.println("Full Car Model X= " + modelX.getManufacturerName() + " : " + modelX.getName());
```
![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CJZP/0)
因此, `Car`是一个类,它具有字段或属性`name``manufacturerName``modelS``Car`类的一个对象。因此`modelS`也具有相同的属性和方法。
确保对象的“信息”(在本例中为`manufacturerName`变量的`name`是私有的并且只能通过这些getter和setter访问是非常标准的。这可以防止调试涉及对象成员变量的代码的问题。如果成员变量是公共的并且由于任何原因程序崩溃您可能会得到一个相当复杂的堆栈跟踪可能很难指出错误。保持变量私有并且只能通过getter和setter访问这将简化此错误消息。

View File

@ -0,0 +1,125 @@
---
title: Collections
localeTitle: 集合
---
# 集合
Java中的Collection是一组可以排序LinkedList或无序Set的对象。 Collection接口位于层次结构的顶部所有其他类和接口都从此接口扩展。它位于java.util包中。
Collection接口还扩展了Iterable接口这意味着java中的每个集合都必须是可迭代的。这反过来意味着for-each循环可用于按顺序获取它们。
```java
public interface Collection<E> extends Iterable<E>
```
此接口提供的一些最常用的方法是:
```java
boolean add(E e) // Adds the specified element to the collection if not present and returns true if this collection changed.
void clear() // Removes all the elements from the collection.
boolean contains(Object o) // Returns true if the specified element is in the collection else false
boolean isEmpty() // Returns true if the collection is empty else false
boolean remove(Object o) // Removes the specifies element and return true on successful removal else false.
int size() // Returns number of items in the collection.
```
这些和其他各种方法必须由实现Collection接口的任何类实现。
## 接口扩展Collection接口
扩展集合接口的其他重要接口是:
组: 仅包含唯一元素的集合。
队列: 实现队列行为,其中元素仅在开头添加并从末尾删除。
列表: 此集合处理对象的列表/序列。
这四个接口CollectionSetQueueList以及SortedSetDeque和NavigableSet构成了集合Collection层次结构。
# LinkedList类
LinkedList是最重要的Collection类之一它提供了双向链表实现。它实现了ListDequeCloneable和Serializable接口。
**创建LinkedList**
```java
LinkedList<Integer> intList = new LinkedList<Integer>(); // Creates a new list of Integer objects.
```
您还可以创建任何其他对象类型的列表。例如。
```java
LinkedList<String> stringList = new LinkedList();
LinkedList<LinkedList<Integer>> listOfList = new LinkedList();
```
注意自JDK 1.5以来Java中的所有集合都已转换为泛型类型
**将元素添加到列表中**
```java
intList.add(new Integer(1)); // Add 1 to the end.
intList.add(2); // This works as Java provides autoboxing and unboxing of primitive datatypes and their respective wrapper classes
intList.addFirst(3); // Add to the beginning of the list
intList.addLast(2); // Add to the end of the list
intList.add(2, 5); // Add element 5 at index 2
```
让我们打印清单
```java
System.out.println(intList); // toString() method is automatically called on the list
```
输出: \[3,1,5,2,2\]
**从列表中检索元素**
```java
intList.get(3); // Returns element at index 3 ie 2
intList.getFirst(); // Get the first element ie 3
intList.getLast(); // Returns last element ie 2
intList.indexOf(2); // Returns first occured index of 2 ie 3
intList.lastIndexOf(2); // Returns last occured index of 2 ie 4
```
**LinkedList作为堆栈**
由于Java没有提供单独的
```java
intList.push(5); // Add element to the end of list. Works same as addLast()
intList.pop(); // Removes and returns the last element of the list.
```
**从列表中删除元素**
```java
intList.remove(3); // Removes the element at index 3 of the list
intList.removeFirst(); // Removes first element of the list
intList.removeLast(); // Removes last element of the list
```
注意上述所有用于删除和获取元素的方法都会在空列表中返回NoSuchElementException。
#### 更多信息:
* 来源: [Java文档](https://docs.oracle.com/javase/9/docs/api/overview-summary.html)

View File

@ -0,0 +1,64 @@
---
title: Comments in Java
localeTitle: Java中的评论
---
## Java中的评论
java中的注释就像现实生活中用于显示一些信息的便利贴其他程序员或开发人员可以阅读和理解这些信息。
最好在代码中添加注释,尤其是在与团队或公司合作时。这有助于未来的开发人员或团队成员在查看代码时更轻松地了解正在发生的事情。注释使您的代码更整洁有序。
编译器和解释器不执行Java注释。
### Java注释的类型
#### 1.单行注释
要创建单行注释,只需在文本前添加两个`//`正斜杠。
```java
// This is how single line comment looks like
```
#### 2.多行注释
要创建多行注释包装`/*`行之间的行到这里`*/`
```java
public class MyFirstJava {
public static void main(String[] args) {
/* This Java Code
Prints out "Hello world"
and you are looking at a multi line comment
*/
System.out.println("Hello World");
}
}
```
#### 3.文件评论
Javadoc工具使用文档注释来创建代码文档。文档注释开发人员使用注释来记录代码例如类的功能或方法的功能。这是由javadoc工具使用的它将编译一组预先格式化的html文件其中包含注释中可用的所有信息。
```java
/**
* The Following Java program displays a random between 0 - 50
* Most Developer dont document simple program like this
*
* @author Quincy Larson
* @version 1.0
*/
public class RandomNumbers{
public static void main(String[] args) {
int random = (int)(Math.random() * 50 + 1);
System.out.println("Hello World");
}
}
```
#### 更多信息:
* [Java资源](http://guide.freecodecamp.org/java/resources/)
* [编译的Javadoc示例](https://docs.oracle.com/javase/8/docs/api/)

View File

@ -0,0 +1,181 @@
---
title: Constructors
localeTitle: 构造函数
---
如果一个对象从一个类复制,那有什么意义呢?我应该能够将数据存储在其中吗?
那时我们使用**getter** 例如getName/ **setter** 例如setName方法或者在本例中使用构造函数来初始化类。基本上每个Java类都有一个构造函数它是在初始化类的任何对象时首先调用的方法。可以把它想象成一些入门代码。
当您编写没有任何构造函数的类时Java编译器会创建一个默认构造函数
```java
public class Car {
private String name;
}
Car modelS = new Car();
```
这种没有参数的初始化是一种调用默认构造函数的方法。您也可以使用这种方式编写默认构造函数:
```java
public class Car {
private String name;
// User Specified Default Constructor
public Car() {
name = "Tesla";
}
}
```
然后,当调用`new Car()` ,变量`name`自动初始化为Carla对象的该实例的“Tesla”。
显然,构造函数与它们完全一样:它们用于`construct` ie实例化特定类的对象。
构造函数看起来类似于方法声明,但在它们的意义上略有不同:
1. 被命名与该类完全相同。
2. 没有返回类型。
因此,使用`constructors`的目的是提供:
1. 一种实例化对象的方法。
2. 为对象属性提供初始值。
3. 控制对象的创建方式。
让我们看另一个例子。比如说,本田(汽车制造商)希望所有汽车都被命名为`Honda <a name>` 。为了强制执行此操作,我们可以使用如下类来表示:
```java
public class Car {
private String name;
// Constructor.
public Car(String model){
this.name = "Honda " + model;
}
public String getName(){
return this.name;
}
public static void main(String args[]){
Car car = new Car("Civic");
System.out.println( car.getName() );
}
}
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CTJ4/1)
请注意当我们以这种方式编写构造函数即提供参数我们控制第3点 `Car`实例的创建方式。简而言之,我们在这个例子中说, **你必须提供一个模型名称才能获得Car类的实例**
为什么这很重要?有时您希望在整个应用程序中使用`one and only one`类的实例。实现此目的的一种方法是使用`private`构造函数。
假设您需要一个班级来代表银行。您不希望人们创建`Bank`实例。所以,你设计你的课程:
```java
public class Bank {
private static Bank instance;
private Bank(){
}
public static Bank getInstance(){
if(null == instance){
instance = new Bank();
}
return instance;
}
}
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CTJz/0)
请注意,构造函数是`private` 。这强制了这样一个事实,即不允许其他人创建银行的实例。
事实上,如果在另一个班级,你尝试:
```java
Bank account = new Bank(); // Throws a compilation error: Bank() has private access in Bank.
```
因此,获取实例访问权限的唯一方法是使用`Bank.getInstance()` 。这样的实例称为`Singleton`因为在应用程序的整个生命周期中您只能获得一个实例每个VM都是精确的
一个类中可以有许多构造函数。但它们应该在方法参数上有所不同。这是构造函数重载。确切地说我们说当有两个或多个具有相同名称但方法参数不同的构造函数时会发生构造函数重载。因此这两个函数具有不同的方法签名并且被Java视为完全不同的构造函数。例如
```java
public class Car {
private String name;
private String carType;
// Constructor.
public Car(){
this.name = "No Name";
this.carType = "No Type";
}
public Car(String model){
this.name = "Honda " + model;
}
public Car(String model, String carType){
this.name = model;
this.carType = carType;
}
public String getName(){
return this.name;
}
public String getCarType(){
return this.name;
}
public static void main(String args[]){
Car car = new Car("Civic");
System.out.println( car.getName() );
// Other Way To Initialize
Car car = new Car("Civic","Sedan");
System.out.println( car.getName() + " "+ car.getCarType() );
}
}
```
因此,获取实例访问权限的唯一方法是使用`Bank.getInstance()` 。这样的实例称为`Singleton`因为在应用程序的整个生命周期中您只能获得一个实例每个VM都是精确的
## 复制构造函数
复制构造函数是一个构造函数,它通过使用先前创建的同一类的对象初始化它来创建对象。复制构造函数用于 -
1. 从另一个相同类型的对象初始化。
2. 复制对象以将其作为参数传递给函数。
3. 复制对象以从函数返回它。 这是一个程序,它显示了复制构造函数的简单用法:
```Java
class Complex {
private double re, im;
// A normal parametrized constructor
public Complex(double re, double im) {
this.re = re;
this.im = im;
}
// Copy constructor
Complex(Complex c) {
System.out.println("Copy constructor called");
re = c.re;
im = c.im;
}
}
}
```
[运行完整的代码](https://repl.it/MwnJ)
// ##构造函数链接

View File

@ -0,0 +1,111 @@
---
title: Control Flow
localeTitle: 控制流
---
# 控制流
控制流语句正是该术语的含义。它们是基于决策,循环和分支改变执行流程的语句,以便程序可以有条件地执行代码块。
首先Java具有以下用于流控制的构造
* `if`
```java
if( <expression that results in a boolean> ){
//code enters this block if the above expression is 'true'
}
```
* `if...else`
```java
if( <expression that results in a boolean> ){
//execute this block if the expression is 'true'
} else{
//execute this block if the expression is 'false'
}
```
* `switch`
当有多个值和要检查的案例时Switch是`if...else`构造的替代方案。
```java
switch( <integer / String / Enum > ){
case <int/String/Enum>:
<statements>
break;
case <int/String/Enum>:
<statements>
break;
default:
<statements>
}
```
注:程序流程`falls through`下一`case` ,如果`break`语句丢失。例如,假设你对办公室里的每个人都说标准的“你好”,但对于坐在你旁边的女孩来说,你对你的老板说得好脾气。表示方式如下:
```java
switch(person){
case 'boss':
soundGrumpy();
break;
case 'neighbour':
soundExtraNice();
break;
case 'colleague':
soundNormal();
break;
default:
soundNormal();
}
```
```
Note: The `default` case runs when none of the `case` matches. Remember that when a case has no `break` statement, it `falls through` to the next case and will continue to the subsequent `cases` till a `break` is encountered. Because of this, make sure that each case has a `break` statement. The `default` case does not require a `break` statement.
```
* `nested statements`
可以嵌套任何先前的控制流。这意味着您可以嵌套`if` `if..else`和`switch..case`语句。也就是说,您可以将这些语句的任意组合放在另一个语句中,并且`nesting`的深度没有限制。
例如,让我们考虑以下场景:
* 如果你的钱少于25美元你可以给自己一杯咖啡。
* 如果你有超过25美元但不到60美元你会得到一个体面的饭菜。
* 如果你有超过60美元但不到100美元你会得到一顿不错的美食和一杯葡萄酒。
* 然而当你有超过100美元取决于你与谁在一起你要么去一个烛光晚餐与你的妻子或你去体育酒吧与你的朋友
表示这一点的方法之一是:
```java
int cash = 150;
String company = "friends";
if( cash < 25 ){
getCoffee();
} else if( cash < 60 ){
getDecentMeal();
} else if( cash < 100 ){
getDecentMeal();
getGlassOfWine();
} else {
switch(company){
case "wife":
candleLitDinner();
break;
case "friends":
meetFriendsAtSportsBar();
break;
default:
getDecentMeal();
}
}
```
在此示例中,将执行`meetFriendsAtSportsBar()` 。
![:rocket:](https://forum.freecodecamp.org/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CJZi/1)

View File

@ -0,0 +1,16 @@
---
title: Data Abstraction
localeTitle: 数据抽象
---
## 定义
根据字典,抽象是处理想法而不是事件的质量。
同样在面向对象的编程中,抽象是从用户隐藏实现细节的过程,只有功能将被提供给用户。换句话说,用户将获得关于对象做什么而不是如何做的信息。
在Java中使用抽象类和接口实现抽象。
## 资源
[教程点 - Java抽象类和接口](https://www.tutorialspoint.com/java/java_abstraction.htm)
[Java教程 - Java抽象方法和类](https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)

View File

@ -0,0 +1,206 @@
---
title: Data Types
localeTitle: 数据类型
---
# 数据类型
Java是一种强类型语言。这意味着在Java中每种数据类型都有自己的严格定义。当数据类型之间发生任何冲突时没有隐式数据类型转换。程序员应明确声明数据类型的任何更改。
Java定义了8种原始数据类型 `byte` `short` `int` `long` `char` `float` `double``boolean`
它们分为以下几类:
* 整型
* 浮点数字
* 人物
* 布尔类型
下面给出了每种数据类型的详细信息:
## 整数:
它们有四种类型: `byte` `short` `int` `long` 。重要的是要注意这些是正负值。有符号整数使用[2的补码](http://www.ele.uri.edu/courses/ele447/proj_pages/divid/twos.html)存储在计算机中。它包含负值和正值,但采用不同的格式,如`(-1 to -128)``(0 to +127)` 。无符号整数可以保存较大的正值,而不包含负值`(0 to 255)` 。与C ++不同Java中没有无符号整数。
### 字节:
字节数据类型是8位带符号的二进制补码整数。
```
Wrapper Class: Byte
Minimum value: -128 (-2^7)
Maximum value: 127 (2^7 -1)
Default value: 0
Example: byte a = 10 , byte b = -50;
```
### 短:
短数据类型是16位带符号的二进制补码整数。
```
Wrapper Class: Short
Minimum value: -32,768 (-2^15)
Maximum value: 32,767 (2^15 -1)
Default value: 0.
Example: short s = 10, short r = -1000;
```
### INT
int数据类型是32位带符号的二进制补码整数。除非存在对内存的担忧否则它通常用作整数值的默认数据类型。
```
Wrapper Class: Integer
Minimum value: (-2^31)
Maximum value: (2^31 -1)
The default value: 0.
Example: int a = 50000, int b = -20
```
### 长:
长数据类型是64位带符号的二进制补码整数。
```
Wrapper Class: Long
Minimum value: (-2^63)
Maximum value: (2^63 -1)
Default value: 0L.
Example: long a = 100000L, long b = -600000L;
By default all integer type variable is "int". So long num=600851475143 will give an error.
But it can be specified as long by appending the suffix L (or l)
```
## 浮点:
这些也称为实数,用于涉及分数精度的表达式。它们有两种类型: `float` `double` 。在货币或研究数据等精确数据的情况下,实际上可以避免浮动。
### 浮动:
float数据类型是单精度32位[IEEE 754浮点数](http://steve.hollasch.net/cgindex/coding/ieeefloat.html) 。
```
Wrapper Class: Float
Float is mainly used to save memory in large arrays of floating point numbers.
Default value: 0.0f.
Example: float f1 = 24.5f;
The default data type of floating-point number is double. So float f = 24.5 will introduce an error.
However, we can append the suffix F (or f) to designate the data type as float.
```
### 双:
双数据类型是双精度64位[IEEE 754浮点](http://steve.hollasch.net/cgindex/coding/ieeefloat.html) 。此数据类型通常是默认选择。绝不应将此数据类型用于精确值,例如货币。
```
Wrapper Class: Double
This data type is generally used as the default data type for decimal values.
Default value: 0.0d.
Example: double d1 = 123.400778;
```
## 字符:
我们使用此数据类型来存储字符。这与C / C ++中的char不同。 Java使用`UNICODE` ,国际公认的字符集。 Java中的Char为16位长而C / C ++中的Char为8位。
```
Wrapper Class: Character
Minimum value: '\u0000' (or 0).
Maximum value: '\uffff' (or 65,535).
Default value: null ('\u0000').
Example: char letterA ='a';
```
## 布尔:
这用于存储逻辑值。布尔类型的值可以为true或false。此类型通常由关系运算符返回。
```
There are only two possible values: true and false.
Wrapper Class: Boolean
This data type is used for simple flags that track true/false conditions.
Default value is false.
Example: boolean b = true, boolean b1 = 1(this is not possible in java and give incompatible type error), boolean b2;
```
## 参考数据类型:
除了原始数据类型之外还有使用不同类的构造函数创建的引用变量。引用变量用于任何类以及数组字符串扫描程序随机模具等。引用变量使用new关键字初始化。
示例:
```java
public class Box{
int length, breadth, height;
public Box(){
length=5;
breadth=3;
height=2;
}
}
class demo{
public static void main(String args[]) {
Box box1 = new Box(); //box1 is the reference variable
char[] arr = new char[10]; //arr is the reference variable
}
}
```
## 串:
String不是原始数据类型但它允许您在数组中存储多个字符数据类型并且可以使用许多方法。当用户键入数据并且您必须对其进行操作时它会非常常用。
在下面的示例中,我们尝试从字符串中删除所有字母并输出它:
```java
String input = "My birthday is 10 January 1984 and my favorite number is 42";
String output = "";
for(int i=0;i<input.length();i++){
//if the character at index i on the string is a letter or a space, move on to the next index
if(Character.isLetter(input.charAt(i)) || input.charAt(i)==' '){
continue;
}
output = output + input.charAt(i); //the number is added onto the output
}
System.out.println(output);
```
输出:
```
10198442
```

View File

@ -0,0 +1,50 @@
---
title: Defining Attributes
localeTitle: 定义属性
---
## 定义属性
类具有属性和方法。属性基本上是类中的变量。
**_例_**
```java
public class Vehicle {
int maxSpeed;
int wheels;
String color;
void horn() {
System.out.println("Beep beep!");
}
}
```
`maxSpeed` `wheels``color`都是Vehicle类的属性`horn()`是唯一的方法。
### 创建对象
我们可以创建Vehicle类的多个对象并使用点语法来访问它们的属性和方法。
```java
class MyClass {
public static void main(String[] args) {
Vehicle v1 = new Vehicle();
Vehicle v2 = new Vehicle();
v1.color = "red";
v2.horn();
}
}
```
### 可见性修饰符
在上面的Vehicle示例中声明属性时没有可见性修饰符例如publicprivate或protected。如果属性延迟中不包含修饰符则默认为“package private”这意味着可以使用“。”直接访问该属性。由同一包中的任何其他类的点表示法。
'public'变量可以从任何类访问 “protected”变量可以由同一个包中的任何类访问也可以由具有父子关系的任何其他包中的子类访问 'private'变量只能在声明它们的类中访问 'package private'成员可以通过同一个包中的类访问
'public'变量方法构造函数和类只有一个可以声明为public。 'protected'变量方法和构造函数可以声明为private但不能声明为类和接口。 'private'变量方法和构造函数可以声明为private但不能声明为类和接口。 'default',变量,方法,构造函数和类可以是默认类型(通过不写任何东西来声明)。
#### public> protected> default> private基于易于访问性
将类的所有属性设为私有通常是一个好主意并通过使用“getter”和“setter”方法来控制对它们的访问。

View File

@ -0,0 +1,64 @@
---
title: Checking for Equality
localeTitle: 检查平等
---
# 检查平等
在Java中有两种方法可以检查两个变量是否“相同” `==``.equals()` 。但是,这两种方法的工作方式不同。
## `==`运算符
Java中的基本相等操作 `==``var1 == var2` ,检查`var1``var2`是否指向同一个_对象引用_ 。 也就是说,如果`var1`与内存中的类的_实例_与`var2` ,则`var1 == var2`为true。
但是,如果将`var1``var2`创建为类的两个单独实例(即使用`new`关键字),则`var1 == var2`将为false。即使两个对象碰巧包含完全相同的属性和值 `==`比较也不会通过,因为它们不指向内存中的同一对象。
对于原始变量类型,例如`int``double` `==`运算符总是可以用于检查相等性,因为它们的值直接与变量一起存储(而不是作为对内存中另一个槽的引用)。
```java
int var1 = 1;
int var2 = 1;
System.out.println(var1 == var2) // true
MyObject obj1 = new MyObject();
MyObject obj2 = obj1;
MyObject obj3 = new MyObject();
System.out.println(obj1 == obj2) // true
System.out.println(obj1 == obj3) // false
System.out.println(obj2 == obj3) // false
```
## `.equals()`方法
Java中的内置`Object`类(所有其他类自动扩展)包含许多有用的内置方法。一种这样的方法是`equals()` ,它将另一个对象作为其参数,并根据该类的相关逻辑返回两个对象是否应被视为“相等”。
'String'类是覆盖'equals'方法的类的最常见示例之一。当比较两个'String'是否相等时,你需要使用'equals'方法,因为'=='将无法正常工作。
```java
String s1 = "Bob";
String s2 = "ob";
s2 = "B" + s2; //s2 now is also "Bob"
System.out.println(s1 == s2); //false
System.out.println(s1.equals(s2)); //true
```
在Java中创建新类时通常需要覆盖`equals()`方法,以便提供更有意义的方法来比较同一个类的两个对象。如何实现此方法完全取决于开发人员的判断。
例如,如果两个`Person``name``dateOfBirth`相同,则可以认为这两个`Person`应被视为“相等”。这个逻辑将在你的`Person`类的`equals()`方法中实现:
```java
public class Person {
public String name;
public Date dateOfBirth;
public boolean equals(Person person) {
return this.name.equals(person.name) && this.dateOfBirth.equals(person.dateOfBirth);
}
}
```
Java中的大多数内置类以及流行库提供的类将以有意义的方式实现`equals()`方法。
例如, `java.util.Set`接口指定`Set``equals()`方法将返回true如果“指定的对象也是一个集合两个集合具有相同的大小并且包含指定集合的每个成员在这套“。
但是,如果一个类没有覆盖默认的`equals()`实现,那么将应用默认实现,它只使用`==`运算符来比较这两个对象。

View File

@ -0,0 +1,60 @@
---
title: Final
localeTitle: 最后
---
## 最后
您使用`final`关键字来标记变量常量以便只能分配一次。因此您必须使用值初始化最终变量。如果未初始化在声明时在Constructor内部或内部静态块中将发生编译时错误。
**_例_**
```java
class MyClass {
public static final double PI = 3.14;
public static void main(String[] args){
System.out.println(PI);
}
}
```
PI现在是一个常数。任何为其赋值的尝试都会导致错误。
* * *
如果您将任何方法设为最终方法,则无法覆盖它。
```java
class Bike{
final void run(){System.out.println("running");}
}
class Honda extends Bike{
void run(){System.out.println("running safely with 100kmph");}
public static void main(String args[]){
Honda honda= new Honda();
honda.run();
}
}
```
输出将是 - 输出:编译时错误
* * *
如果您将任何课程作为最终成绩,则无法对其进行扩展。
```java
final class Bike{}
class Honda1 extends Bike{
void run(){System.out.println("running safely with 100kmph");}
public static void main(String args[]){
Honda1 honda= new Honda();
honda.run();
}
}
```
输出将是 - 输出:编译时错误

View File

@ -0,0 +1,22 @@
---
title: Finally
localeTitle: 最后
---
## 最后
当try块退出时finally块总是执行。这确保即使发生意外异常也会执行finally块。但最终不仅仅是异常处理有用 - 它允许程序员避免因返回继续或中断而意外绕过清理代码。将清理代码放在finally块中总是一种很好的做法即使没有预期的例外情况也是如此。
**_例_**
```java
try {
// Normal execution path
throw new EmptyStackException();
} catch (ExampleException ee) {
// deal with the ExampleException
} finally {
// This optional section is executed upon termination of any of the try or catch blocks above,
// except when System.exit() is called in "try" or "catch" blocks;
}
```

View File

@ -0,0 +1,108 @@
---
title: Garbage Collection
localeTitle: 垃圾收集
---
# Java中的垃圾收集
在像C / C ++这样的语言中,程序员有责任创建和销毁对象。但是如果程序员没有履行职责,则可能无法为创建新对象提供足够的内存,程序可能会终止导致**OutOfMemoryErrors** 。
Java使程序员免于内存管理任务并且自己回收不再使用的对象所占用的内存。 java中的垃圾收集由名为**Garbage Collector**的守护程序线程执行。当新对象缺少内存(堆)时, **JVMJava虚拟机会**调用它。
## 当一个对象有资格进行垃圾收集?
* 如果无法从任何活动线程或任何静态引用访问对象,则该对象符合垃圾收集条件。
* 如果对象的所有引用都为null则该对象符合Garbage Collection的条件。
```java
Integer n = new Integer();
n = null; //the Integer object is no longer accessible
```
* 循环依赖不计为引用因此如果对象X具有对象Y的引用而对象Y具有对象X的引用并且它们没有任何其他实时引用则对象X和Y都将有资格进行垃圾收集。
## 如何手动使对象符合垃圾收集条件?
* 尽管程序员不是要销毁对象的任务但在使用它之后使对象无法访问因此符合GC条件是一种很好的编程习惯。
* 通常有四种不同的方法可以使对象符合垃圾回收的条件。
1. 取消引用变量
2. 重新分配参考变量
3. 对象在块内创建,一旦控制退出该块,引用就会超出范围。
4. [隔离岛](http://www.geeksforgeeks.org/island-of-isolation-in-java/)
## 请求JVM运行垃圾收集器1的方
* 尽管使对象符合垃圾收集条件但它依赖于JVM自行决定运行垃圾收集器来销毁垃圾收集器。
* 我们也可以请求JVM运行垃圾收集器。有两种方法可以做到
1. 使用_**System.gc**_方法System类包含静态方法gc用于请求JVM运行Garbage Collector。
2. 使用_**Runtime.getRuntime。gc**_方法运行时类允许应用程序与运行应用程序的JVM进行交互。因此通过使用其gc方法我们可以请求JVM运行垃圾收集器。
```java
// Java program to request
// JVM to run Garbage Collector
public class Test
{
public static void main(String[] args) throws InterruptedException
{
Test test1 = new Test();
Test test2 = new Test();
// Nullifying the reference variable
test1 = null;
// requesting JVM for running Garbage Collector
System.gc();
// Nullifying the reference variable
test2 = null;
// requesting JVM for running Garbage Collector
Runtime.getRuntime().gc();
}
@Override
// finalize method is a method which is called on object once
// before garbage collector is destroying it and reclaiming its memory
protected void finalize() throws Throwable
{
System.out.println("Garbage collector is called");
System.out.println("Object garbage collected : " + this);
}
}
```
```java
OUTPUT -
Garbage collector called
Object garbage collected : Test@46d08f12
Garbage collector called
Object garbage collected : Test@481779b8
```
注意
1. 无法保证上述两种方法中的任何一种都能运行垃圾收集器。
2. 调用System.gc实际上等同于调用Runtime.getRuntime。gc
## 对象终结
* 对象具有与其关联的资源。他们有责任释放资源。
* finalize在Object类中声明并且在销毁对象之前由垃圾收集器调用一次。在垃圾收集器回收其区域之前对象可以使用此方法jst进行任何最后操作。
* finalize方法存在于Object类中具有以下原型。
```java
protected void finalize() throws Throwable
```
## 注1
1. 垃圾收集器调用的finalize方法而不是JVM。虽然垃圾收集器是JVM的模块之一。
2. 对象类finalize方法具有空实现因此建议覆盖finalize方法以处置系统资源或执行其他清理。
3. 对于任何给定对象finalize方法永远不会被多次调用。
4. 如果finalize方法抛出未捕获的异常则忽略该异常并终止该对象的终止。
### 来源
1. [geeksforgeeks。](http://www.geeksforgeeks.org/garbage-collection-java/)访问时间2017年10月24日。

View File

@ -0,0 +1,79 @@
---
title: Generics
localeTitle: 泛型
---
# 泛型
Java Generics是一种方便地使用特定数据类型的集合和类而不必将数据转换回原始数据类型的方法。这可以防止以编译时和运行时错误的形式出现很多问题。
简单地说Generics允许你明确地说例如一个ArrayList对象保存Integers这样当你调用get方法时你不需要在Object和Integer之间进行转换。下面是一个如何在Generics之前使用ArrayList的示例。
```java
import java.util.ArrayList;
public class Example {
private ArrayList classNames;
public Example() {
classNames = new ArrayList();
}
public void addName(String name) {
classNames.add(name);
}
public String getNameAtIndex(int index) {
return (String) classNames.get(index);
}
}
```
上面的主要问题是如果以某种方式将类型为String的Object添加到ArrayList中`getNameAtIndex(int index)`方法将导致运行时错误。为了解决这个问题,我们使用泛型。
泛型的语法非常简单。下面是实例化ArrayList的示例。
```java
import java.util.ArrayList;
public class Example {
private ArrayList<String> classNames;
public Example() {
classNames = new ArrayList<String>();
}
public void addName(String name) {
classNames.add(name);
}
public String getNameAtIndex(int index) {
return classNames.get(index);
}
}
```
创建自己的Generic类的语法如下。
```java
import java.util.ArrayList;
public class Example <T> {
private ArrayList<T> classNames;
public Example() {
classNames = new ArrayList<T>();
}
public void addName(T name) {
classNames.add(name);
}
public T getNameAtIndex(int index) {
return classNames.get(index);
}
}
```
请注意在命名类时在尖括号内您可以确保Generic类型是那样的 你要。例如如果您想确保类型可以作为String的形式读取那么您将去`<T extends String>`
请注意,字母`T`是占位符,只要您使用相同的字母,就可以制作任何您喜欢的内容 整个班级。

View File

@ -0,0 +1,73 @@
---
title: Getters & Setters
localeTitle: 吸气者和二传手
---
# 吸气者和二传手
Getters和Setter用于有效保护您的数据尤其是在创建类时。对于每个实例变量getter方法返回其值而setter方法设置或更新其值。吸气剂和固定剂也分别称为存取器和变换器。
按照惯例getter以get开头后跟变量名变量名的第一个字母大写。 Setter以set开头后跟变量名变量名的第一个字母大写。
**_例_**
```java
public class Vehicle {
private String color;
// Getter
public String getColor() {
return color;
}
// Setter
public void setColor(String c) {
this.color = c;
}
}
```
getter方法返回属性的值。 setter方法接受一个参数并将其分配给属性。
一旦定义了getter和setter我们就在main中使用它
```java
public stativ void main(String[] args) {
Vehicle v1 = new Vehicle();
v1.setColor("Red");
System.out.println(v1.getColor());
}
// Outputs "Red"
```
* * *
Getters和setter允许控制值。在实际设置值之前您可以在setter中验证给定值。
## 为什么吸气和安装?
通过使用getter和setter程序员可以控制如何访问和更新其重要变量例如更改指定范围内变量的值。考虑以下setter方法的代码
```java
public void setNumber(int num) {
if (num < 10 || num > 100) {
throw new IllegalArgumentException();
}
this.number = num;
}
```
这可确保number的值始终设置在10到100之间。如果程序员允许直接更新变量号则调用者可以为其设置任意值
```java
obj.number = 3;
```
这违反了该变量的值范围从10到100的约束。由于我们不希望发生这种情况因此将变量号隐藏为私有并使用setter会阻止它。 另一方面getter方法是外界读取变量值的唯一方法
```java
public int getNumber() {
return this.number;
}
```

119
guide/chinese/java/index.md Normal file
View File

@ -0,0 +1,119 @@
---
title: Java
localeTitle: Java的
---
**什么是Java**
[Java](https://www.oracle.com/java/index.html)是[Sun Microsystems](https://en.wikipedia.org/wiki/Sun_Microsystems)在1995年开发的一种编程语言后来被[Oracle](http://www.oracle.com/index.html)收购。它现在是一个完整的平台包含许多标准API开源API工具庞大的开发人员社区用于构建大小公司最值得信赖的企业解决方案。 [Android](https://www.android.com/)应用程序开发完全由Java及其生态系统完成。要了解有关Java的更多信息请阅读[本文](https://java.com/en/download/faq/whatis_java.xml)和[此内容](http://tutorials.jenkov.com/java/what-is-java.html) 。
## 版
最新版本是[Java 11](http://www.oracle.com/technetwork/java/javase/overview) 它于2018年发布对以前的版本Java 10进行了[各种改进](https://www.oracle.com/technetwork/java/javase/11-relnote-issues-5012449.html) 。但是出于所有意图和目的我们将在本维基中使用Java 8来完成所有教程。
Java也分为几个“版本”
* [SE](http://www.oracle.com/technetwork/java/javase/overview/index.html) - 标准版 - 适用于桌面和独立服务器应用程序
* [EE](http://www.oracle.com/technetwork/java/javaee/overview/index.html) - Enterprise Edition - 用于开发和执行嵌入Java服务器的Java组件
* [ME](http://www.oracle.com/technetwork/java/embedded/javame/overview/index.html) - Micro Edition - 用于在移动电话和嵌入式设备上开发和执行Java应用程序
## 安装JDK还是JRE
从[官方网站](http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html)下载最新的Java二进制文件。在这里您可能会遇到一个问题下载哪个JDK或JRE JRE代表Java Runtime Environment它是依赖于平台的Java虚拟机来运行Java代码JDK代表Java Development Kit它由大多数开发工具组成最重要的是编译器`javac` 以及JRE。因此对于普通用户而言JRE就足够了但由于我们将使用Java进行开发因此我们将下载JDK。
## 平台特定安装说明
### 视窗
* 下载相关的[.msi](https://en.wikipedia.org/wiki/Windows_Installer)文件x86 / i586用于32位x64用于64位
* 运行.msi文件。它是一个自解压的可执行文件它将在您的系统中安装Java
### Linux的
* 下载适用于您系统的相关[tar.gz](http://www.cyberciti.biz/faq/linux-unix-bsd-extract-targz-file/)文件并安装:
`bash $ tar zxvf jdk-8uversion-linux-x64.tar.gz`
* [基于RPM的Linux平台](https://en.wikipedia.org/wiki/List_of_Linux_distributions#RPM-based)下载相关的[.rpm](https://en.wikipedia.org/wiki/RPM_Package_Manager)文件并安装:
`bash $ rpm -ivh jdk-8uversion-linux-x64.rpm`
* 用户可以选择安装JavaOpenJDK或Oracle JDK的开源版本。虽然OpenJDK正在积极开发并与Oracle JDK同步但它们在[许可方面](http://openjdk.java.net/faq/)有所不同。然而很少有开发人员抱怨Open JDK的稳定性。 **Ubuntu**说明:
打开JDK安装
`bash sudo apt-get install openjdk-8-jdk`
Oracle JDK安装
`bash sudo add-apt-repository ppa:webupd8team/java sudo apt-get update sudo apt-get install oracle-java8-installer`
### 苹果电脑
* 从Oracle下载中下载Mac OSX .dmg可执行文件
* 或者使用[Homebrew](http://brew.sh/) [安装](http://stackoverflow.com/a/28635465/2861269)
`bash brew tap caskroom/cask brew install brew-cask brew cask install java`
### 验证安装
通过打开命令提示符Windows/ Windows Powershell / TerminalMac OS和\* Unix并检查Java运行时和编译器的版本来验证Java是否已在系统中正确安装
```
$ java -version
java version "1.8.0_66"
Java(TM) SE Runtime Environment (build 1.8.0_66-b17)
Java HotSpot(TM) 64-Bit Server VM (build 25.66-b17, mixed mode)
$ javac -version
javac 1.8.0_66
```
**提示** :如果您在`java``javac`或两者上都收到诸如“未找到命令”之类的错误请不要惊慌它只是您的系统PATH未正确设置。对于Windows请参阅[此StackOverflow答案](http://stackoverflow.com/questions/15796855/java-is-not-recognized-as-an-internal-or-external-command)或[本文](http://javaandme.com/)有关如何执行此操作。还有[Ubuntu](http://stackoverflow.com/questions/9612941/how-to-set-java-environment-path-in-ubuntu)和[Mac的](http://www.mkyong.com/java/how-to-set-java_home-environment-variable-on-mac-os-x/)指南。如果你仍然想不通,不要担心,只要在我们的[Gitter房间](https://gitter.im/FreeCodeCamp/java)问我们!
## JVM
好了既然我们完成了安装那么我们首先要开始了解Java生态系统的细节。 Java是一种[解释和编译的](http://stackoverflow.com/questions/1326071/is-java-a-compiled-or-an-interpreted-programming-language)语言,即我们编写的代码被编译为字节码并被解释为运行。我们在.java文件中编写代码Java将它们编译为[字节码](https://en.wikipedia.org/wiki/Java_bytecode) ,这些[字节码](https://en.wikipedia.org/wiki/Java_bytecode)在Java虚拟机或JVM上运行以便执行。这些字节码通常具有.class扩展名。
Java是一种非常安全的语言因为它不会让您的程序直接在计算机上运行。相反您的程序在名为JVM的虚拟机上运行。此虚拟机公开了几个API用于您可以进行的低级机器交互但除此之外您无法明确地使用机器指令。这增加了巨大的安全性。
此外一旦编译了字节码它就可以在任何Java VM上运行。该虚拟机依赖于机器即它具有不同的WindowsLinux和Mac实现。但是由于这个VM你的程序可以保证在任何系统中运行。这种理念被称为[“一次编写,随处运行”](https://en.wikipedia.org/wiki/Write_once,_run_anywhere) 。
## 你好,世界!
我们来编写一个示例Hello World应用程序。打开所选的任何编辑器/ IDE并创建一个文件`HelloWorld.java`
```
public class HelloWorld {
public static void main(String[] args) {
// Prints "Hello, World" to the terminal window.
System.out.println("Hello, World");
}
}
```
**NB**请记住Java文件名应该**与公共类的名称完全相同**才能编译!
现在打开终端/命令提示符。将终端/命令提示符中的当前目录更改为文件所在的目录。并编译文件:
```
$ javac HelloWorld.java
```
现在使用`java`命令运行该文件!
```
$ java HelloWorld
Hello, World
```
恭喜您的第一个Java程序已成功运行。这里我们只是打印一个字符串将其传递给API `System.out.println` 。我们将介绍代码中的所有概念,但欢迎您[仔细查看](https://docs.oracle.com/javase/tutorial/getStarted/application/) !如果您有任何疑问或需要其他帮助,请随时在我们的[Gitter Chatroom](https://gitter.im/FreeCodeCamp/java)联系我们!
## 文档
Java有大量[文档记录](https://docs.oracle.com/javase/8/docs/) 因为它支持大量的API。如果您使用的是Eclipse或IntelliJ IDEA等任何主要IDE您会发现其中包含Java文档。
此外这里是Java编码的免费IDE列表
* [NetBeans的](https://netbeans.org/)
* [日食](https://eclipse.org/)
* [IntelliJ IDEA](https://www.jetbrains.com/idea/features/)
* [Android Studio](https://developer.android.com/studio/index.html)
* [BlueJ的](https://www.bluej.org/)
* [jEdit的](http://www.jedit.org/)
* [Oracle JDeveloper](http://www.oracle.com/technetwork/developer-tools/jdev/overview/index-094652.html)

View File

@ -0,0 +1,53 @@
---
title: Inheritance Basics
localeTitle: 继承基础
---
# 继承基础
你成功创建了一个Car类真是太棒了。但是等等特斯拉汽车应该是电动车我想要一个电动车类但它也应该具有原始`Car`类的属性。
解决方案: **继承** 。 Java提供了一种“继承”父属性的简洁方法
```java
public class Car {
private String name;
private String manufacturerName;
public Car(String name, String man) {
this.name = name;
this.manufacturerName = man;
}
// Getter method
public String getName() {
return name;
}
// Getter method
public String getManufacturerName() {
return manufacturerName;
}
}
public class ElectricCar extends Car {
public ElectricCar(String name, String man) {
super(name, man);
}
public void charge() {
System.out.println("Charging ...");
}
}
ElectricCar modelS = new ElectricCar("Model S","Tesla");
// prints Tesla
System.out.println(modelS.getManufacturerName());
// prints Charging ...
modelS.charge();
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CJZY/0)
在这里看,类`ElectricCar``Car`类继承或`extends`公共方法,并且有自己的方法和属性。传递信息的酷方式!
另请注意这里使用[super](https://docs.oracle.com/javase/tutorial/java/IandI/super.html)关键字。由于我们的`Car`类有一个构造函数,所以我们也必须从子类初始化该构造函数。我们使用`super`关键字来做到这一点。阅读更多关于继承的信息 。

View File

@ -0,0 +1,192 @@
---
title: Inheritance
localeTitle: 遗产
---
# 遗产
Java继承是指Java类从其他类`inherit`属性的能力。可以把它想象成一个从父母那里继承属性的孩子这个概念非常相似。在Java lingo中它也被称为_扩展_类。一些简单的事情要记住
* 扩展或继承的**类**称为**子类**
* 正在扩展或继承的**类**称为**超类**
因此继承为Java提供了_重用_代码或在类之间共享代码的强大功能
让我们用`Vehicle`类和`Car`类的经典示例来描述它:
```java
public class Vehicle {
public void start() {
// starting the engine
}
public void stop() {
// stopping the engine
}
}
public class Car extends Vehicle {
int numberOfSeats = 4;
public int getNumberOfSeats() {
return numberOfSeats;
}
}
```
在这里,我们可以看到`Car`类继承了`Vehicle`类的属性。因此,我们不必为`Car`的方法`start()``stop()`编写相同的代码,因为这些属性可以从其父类或超类中获得。因此,从`Car`类创建的对象_也_将具有这些属性
```java
Car tesla = new Car();
tesla.start();
tesla.stop();
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CJXz/0)
但是,父类是否有孩子的方法?不,它没有。
因此,每当您需要在多个类之间共享一些共同的代码时,最好有一个父类,然后在需要时扩展该类!减少代码行数,使代码模块化,并简化测试。
## 什么可以继承?
* 来自父级的所有`protected``public`字段和方法
## 什么不能继承?
* `private`领域和方法
* 构造函数。虽然子类构造函数_必须_调用超类构造函数如果已定义稍后详细说明
* 多个班级。 Java仅支持**单继承** ,也就是说,您一次只能继承一个类。
* 场。子类不能覆盖类的各个字段。
## 输入铸造和参考
在Java中可以引用子类作为其超类的_实例_ 。它被称为面向对象编程OOP中的_多态_ ,即对象采用多种形式的能力。例如,可以将`Car`类对象引用为`Vehicle`类实例,如下所示:
```java
Vehicle car = new Car();
```
虽然相反是不可能的:
```java
Car car = new Vehicle(); // ERROR
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CJYB/0)
由于您可以将Java子类作为超类实例引用因此可以轻松地将子类对象的实例强制转换为超类实例。可以将超类对象强制转换为子类类型但_前提是该对象实际上是子类的实例_ 。所以请记住这一点:
```java
Car car = new Car();
Vehicle vehicle = car; // upcasting
Car car2 = (Car)vechile; //downcasting
Bike bike = new Bike(); // say Bike is also a subclass of Vehicle
Vehicle v = bike; // upcasting, no problem here.
Car car3 = (Car)bike; // Compilation Error : as bike is NOT a instance of Car
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CJYM/0)
现在您知道如何通过父子关系共享代码。但是,如果你不喜欢子类中特定方法的实现并想为它编写一个新方法呢?那你怎么办呢?
## 覆盖它!
Java允许您_覆盖_或重新定义超类中定义的方法。例如您的`Car`类具有与父`Vehicle`不同的`start()`实现,因此您执行此操作:
```java
public class Vehicle {
public void start() {
System.out.println("Vehicle start code");
}
}
public class Car extends Vehicle {
public void start() {
System.out.println("Car start code");
}
}
Car car = new Car();
car.start(); // "Car start code"
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CJYZ/1)
因此覆盖子类中的方法非常简单。虽然有一个_陷阱_ 。只有具有与子类方法_完全相同的方法签名_的超类方法才会被覆盖。这意味着子类方法定义必须具有完全相同的名称相同数量和类型的参数并且具有完全相同的顺序。因此 `public void start(String key)`不会覆盖`public void start()`
**备注**
* 您不能覆盖超类的私有方法。 (很明显,不是吗?)
* 如果您在子类中重写的超类方法突然被删除或方法改变了怎么办它会在运行时失败因此Java为您提供了一个漂亮的注释`@Override` ,您可以将其放在子类方法上,这将警告编译器这些事件!
Java中的注释是一种很好的编码实践但它们并不是必需的。编译器足够智能可以自行解决覆盖问题。与其他OOP语言不同Java中的注释不一定会修改方法或添加额外的功能。
## 如何调用超类方法?
有趣的你问一下!只需使用关键字`super`
```java
public class Vehicle() {
public void start() {
System.out.println("Vehicle start code");
}
}
public class Car extends Vehicle {
public void run() {
super.start();
}
}
Car car = new Car();
car.run(); // "Vehicle start code"
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CJY4/0)
**注意** :尽管可以使用`super`调用来调用父方法,但是不能使用链式`super`调用来继承继承层次结构。
## 如何知道班级的类型?
使用`instanceof`关键字。拥有大量的类和子类,知道哪个类是运行时哪个类的子类会有点混乱。因此,我们可以使用`instanceof`来确定对象是类的实例,子类的实例还是接口的实例。
```java
Car car = new Car();
boolean flag = car instanceof Vehicle; // true in this case!
```
## 构造函数和继承
如前所述构造函数不能由子类直接继承。虽然子类_需要_将其父构造函数作为其自己的构造函数中的[第一个操作](http://stackoverflow.com/questions/1168345/why-does-this-and-super-have-to-be-the-first-statement-in-a-constructor)来调用。怎么样?你猜对了,用`super`
```java
public class Vehicle {
public Vehicle() {
// constructor
}
public void start() {
System.out.println("Vehicle start code");
}
}
public class Car extends Vehicle {
public Car() {
super();
}
public void run() {
super.start();
}
}
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CJY8/0)
请记住,如果超类没有定义任何构造函数,则不必在子类中明确地调用它。 Java在内部为您处理在使用除_默认构造_函数之外的任何其他构造函数调用超类的情况下调用`super`构造_函数_ 。
如果没有定义其他构造函数那么Java将调用默认的超类构造函数 _即使未明确定义_ )。
恭喜现在你对继承了解一切阅读有关在Abstract Classes和[Interfaces中](//forum.freecodecamp.com/t/java-docs-interfaces)继承事物的高级方法的更多信息!

View File

@ -0,0 +1,16 @@
---
title: instanceof Operator
localeTitle: instanceof运算符
---
# `instanceof`运算符
`instanceof`运算符允许您检查`IS A`关系的有效性。如果在任何时候,我们不确定这一点,并且我们想在运行时验证这一点,我们可以执行以下操作:
```java
//assuming vehicle is an instance of Class `Car` the expression inside the 'if' will return true
if(vehicle instanceof Car){
//do something if vehicle is a Car
}
```
**注意** 如果将instanceof运算符应用于具有null值的任何变量则返回false。

View File

@ -0,0 +1,265 @@
---
title: Interfaces
localeTitle: 接口
---
# 接口
Java中的接口有点像Class但有一个显着的区别 `interface` _只能_有方法签名字段和默认方法。从Java 8开始您还可以创建[默认方法](https://docs.oracle.com/javase/tutorial/java/IandI/defaultmethods.html) 。在下一个块中,您可以看到一个接口示例:
```java
public interface Vehicle {
public String licensePlate = "";
public float maxVel
public void start();
public void stop();
default void blowHorn(){
System.out.println("Blowing horn");
}
}
```
上面的接口包含两个字段两个方法和一个默认方法。单独使用它并没有多大用处但它们通常与Classes一起使用。怎么样很简单你必须确保一些类`implements`它。
```java
public class Car implements Vehicle {
public void start() {
System.out.println("starting engine...");
}
public void stop() {
System.out.println("stopping engine...");
}
}
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CItd/0)
现在,有一个**基本规则** Class必须实现Interface中的**所有**方法。这些方法必须具有_完全相同的_签名名称参数和例外如界面中所述。类_不需要_声明虽然领域只有方法。
## 接口实例
创建`implements`任何接口的Java类后可以将对象实例作为接口的实例引用。这个概念类似于继承实例化。
```java
// following our previous example
Vehicle tesla = new Car();
tesla.start(); // starting engine ...
```
接口**不能**包含构造函数方法,因此,您**无法**创建接口本身的实例。您必须创建一个实现接口的类的实例来引用它。将接口视为空白合同表单或模板。
你能用这个功能做什么?多态性!您只能使用接口来引用对象实例!
```java
class Truck implements Vehicle {
public void start() {
System.out.println("starting truck engine...");
}
public void stop() {
System.out.println("stopping truck engine...");
}
}
class Starter {
// static method, can be called without instantiating the class
public static void startEngine(Vehicle vehicle) {
vehicle.start();
}
}
Vehicle tesla = new Car();
Vehicle tata = new Truck();
Starter.startEngine(tesla); // starting engine ...
Starter.startEngine(tata); // starting truck engine ...
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CItm/0)
## 但是多个接口怎么样?
是的,您可以在一个类中实现多个接口。在[继承](//forum.freecodecamp.com/t/java-docs-inheritance)的类中您被限制为仅继承一个类在这里您可以扩展任意数量的接口。但是不要忘记实现_所有_接口的所有方法否则编译将失败
```java
public interface GPS {
public void getCoordinates();
}
public interface Radio {
public void startRadio();
public void stopRadio();
}
public class Smartphone implements GPS,Radio {
public void getCoordinates() {
// return some coordinates
}
public void startRadio() {
// start Radio
}
public void stopRadio() {
// stop Radio
}
}
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CIto/0)
## 接口的一些功能
* 您可以在接口中放置变量,但这不是一个合理的决定,因为类不必具有相同的变量。简而言之,避免放置变量!
* 即使您省略了`public`关键字,接口中的所有变量和方法都是公共的。
* 接口无法指定特定方法的实现。它由类来完成。虽然最近有例外(见下文)。
* 如果一个类实现多个接口那么方法签名重叠的可能性很小。由于Java不允许多个方法具有完全相同的签名因此可能会导致问题。有关详细信息请参阅[此问题](http://stackoverflow.com/questions/2598009/method-name-collision-in-interface-implementation-java) 。
## 接口默认方法
在Java 8之前我们无法指示接口具有特定的方法实现。如果突然改变接口定义这会导致很多混乱和代码中断。
假设您编写了一个包含接口的开源库。比如说您的客户即几乎所有世界各地的开发人员都在大量使用它并且很开心。现在您必须通过向接口添加新方法定义来升级库以支持新功能。但是这会破坏_所有_构建因为实现该接口的所有类现在都必须改变。真是个大灾难
值得庆幸的是Java 8现在为我们提供了接口的`default`方法。 `default`方法_可以_ _直接_在Interface中包含自己的实现因此如果类没有实现默认方法编译器将采用接口中提到的实现。不错不是吗因此在您的库中您可以在界面中添加任意数量的默认方法而不必担心破坏任何东西
```java
public interface GPS {
public void getCoordinates();
default public void getRoughCoordinates() {
// implementation to return coordinates from rough sources
// such as wifi & mobile
System.out.println("Fetching rough coordinates...");
}
}
public interface Radio {
public void startRadio();
public void stopRadio();
}
public class Smartphone implements GPS,Radio {
public void getCoordinates() {
// return some coordinates
}
public void startRadio() {
// start Radio
}
public void stopRadio() {
// stop Radio
}
// no implementation of getRoughCoordinates()
}
Smartphone motoG = new Smartphone();
motog.getRoughCoordinates(); // Fetching rough coordinates...
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CItp/0)
### 但是,如果两个接口具有相同的方法签名会发生什么?
真棒的问题。在这种情况下如果你没有在Class中提供实现那么糟糕的编译器会感到困惑并且简单地失败您还必须在类中提供默认方法实现。还有一种使用`super`来调用你喜欢的实现的漂亮方式:
```java
public interface Radio {
// public void startRadio();
// public void stopRadio();
default public void next() {
System.out.println("Next from Radio");
}
}
public interface MusicPlayer {
// public void start();
// public void pause();
// public void stop();
default public void next() {
System.out.println("Next from MusicPlayer");
}
}
public class Smartphone implements Radio, MusicPlayer {
public void next() {
// Suppose you want to call MusicPlayer next
MusicPlayer.super.next();
}
}
Smartphone motoG = new Smartphone();
motoG.next(); // Next from MusicPlayer
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CIts/0)
## 接口中的静态方法
Java 8的另一个新功能是能够向接口添加静态方法。接口中的静态方法几乎与具体类中的静态方法相同。唯一的区别是`static`方法不会在实现接口的类中继承。这意味着在调用静态方法而不是实现它的类时会引用接口。
```java
interface MusicPlayer {
public static void commercial(String sponsor) {
System.out.println("Now for a message brought to you by " + sponsor);
}
public void play();
}
class Smartphone implements MusicPlayer {
public void play() {
System.out.println("Playing from smartphone");
}
}
class Main {
public static void main(String[] args) {
Smartphone motoG = new Smartphone();
MusicPlayer.commercial("Motorola"); // Called on interface not on implementing class
// motoG.commercial("Motorola"); // This would cause a compilation error
}
}
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CIts/9)
## 继承接口
在Java中接口可以_继承_另一个接口通过使用你猜对了 `extends`关键字:
```java
public interface Player {
public void start();
public void pause();
public void stop();
}
public interface MusicPlayer extends Player {
default public void next() {
System.out.println("Next from MusicPlayer");
}
}
```
这意味着,实施类`MusicPlayer`接口必须实现的_所有_方法`MusicPlayer`以及`Player`
```java
public class SmartPhone implements MusicPlayer {
public void start() {
System.out.println("start");
}
public void stop() {
System.out.println("stop");
}
public void pause() {
System.out.println("pause");
}
}
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CIty/0)
哎呀,我忘记了`next()`吗?请注意,因为它是一种`default`方法,所以我根本不需要提供实现。 不适用于JDK <8
所以现在你已经很好地掌握了接口了解抽象类以了解Java如何为您提供另一种定义合同的方法

View File

@ -0,0 +1,11 @@
---
title: Java Bean
localeTitle: Java Bean
---
## Java Bean
这是一个存根。 [帮助我们的社区扩展它](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/quadratic-equations/index.md) 。
[这种快速风格指南有助于确保您的拉取请求被接受](https://github.com/freecodecamp/guides/blob/master/README.md) 。
#### 更多信息:

View File

@ -0,0 +1,37 @@
---
title: JavaFX
localeTitle: JavaFX的
---
## 介绍
JavaFX是由Sun Microsystems创建的用于开发富桌面和Internet应用程序的图形框架。 JavaFX的创建是为了取代旧的Swing和抽象窗口工具包AWT并作为Java语言的Java标准版标准图形API。
## 开发工具
### Gulon SceneBuilder
Gulon Scene Builder是一个用于JavaFX中用户界面UI设计的应用程序。该应用程序使用拖放功能进行快速UI设计允许您在设计时可视化您正在创建的界面。
#### Screeenshots
![场景生成器UI](https://i.imgur.com/3d9SqBR.png)
### FXML
FXML是一种基于XML的标记语言用于在JavaFX中定义结构。 FXML文档在树中布置类中的各种对象类似于XML文档中的标记嵌套。
#### 例:
```XML
<HBox spacing="10" alignment="bottom_right" > // Creates an HBox Object
<Button text="Sign In"/> // Nested inside the HBox is a Button object with the text 'Sign In'
</HBox>
```
### 参考文献:
[FXML文档](https://docs.oracle.com/javase/8/javafx/api/javafx/fxml/doc-files/introduction_to_fxml.html)
[场景生成器教程](https://docs.oracle.com/javase/8/scene-builder-2/get-started-tutorial/overview.htm#JSBGS164)
[官方JavaFX文档](https://docs.oracle.com/javase/8/javase-clienttechnologies.htm)

View File

@ -0,0 +1,37 @@
---
title: Lambda Expressions
localeTitle: Lambda表达式
---
## Lambda表达式
这是一个存根。 [帮助我们的社区扩展它](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/quadratic-equations/index.md) 。
[这种快速风格指南有助于确保您的拉取请求被接受](https://github.com/freecodecamp/guides/blob/master/README.md) 。
Stream Api在java中用于允许链接顺序和聚合操作。流操作本质上是中间的或终端的。
在这个小例子中,您可以看到流的一个实用程序是接收列表中所有对象的某个属性,并使用中间和终端操作将其返回到另一个列表中。
假设您有一个Student对象类。 \`\`的java 公立班学生{ int studentId; String studentName;
public String getStudentName{ return this.studentName; }
public int getStudentId{ 返回this.studentId; } //塞特犬 } \`\`
现在假设您有一个所有学生的列表,并希望获得所有学生姓名的列表。 传统上这看起来像这样。
\`\`的java 名单学生=一些学生对象列表
名单 studentNames = new ArrayList <>; for学生学生{ studentNames.addstudent.getStudentName; } \`\` 虽然这并不可怕,但可以简化。 使用流可以使用一行代码。
\`\`的java 名单学生=一些学生对象列表
名单 studentNames = students.stream。mapString :: getStudentName.collectCollectors.toList; \`\`
学生流api遍历学生列表并使用中间地图功能使用::右侧的任何方法返回新的流列表
终端收集操作将流收集为字符串列表。
这只是java 8中使用的Streams Api的一个用途。还有许多其他应用程序使用其他操作如文档中所示。 [Streams api doc](https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html)
#### 更多信息:

View File

@ -0,0 +1,77 @@
---
title: Break Control Statement
localeTitle: 中断控制声明
---
# 中断控制声明
终止循环并开始执行紧跟循环的代码。如果你有嵌套循环, `break`语句将只结束它所在的循环。
```java
// Loop 1
for (int i = 0; i < 10; i++)
{
// Loop 2
for (int j = 0; j < 10; j++)
{
if (i == 5 && j == 5)
{
break; // Will terminate Loop 2, but Loop 1 will keep going
}
}
}
```
但是,如果您确实想要突破外部循环,可以使用标签退出:
```java
loop1: // This is a label
for (int i = 0; i < 10; i++)
{
// Loop 2
for (int j = 0; j < 10; j++)
{
if (i == 5 && j == 5)
{
break loop1; // Will break out of Loop 1, instead of Loop 2
}
}
}
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CJZA/0)
在搜索数组中的元素时, `break`语句特别有用。使用下面代码中的`break`可以提高效率,因为一旦找到我们要查找的元素( `searchFor` ),循环就会停止,而不是一直到达`arrayInts`的末尾。
```java
int j = 0;
int[] arrayOfInts = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int searchFor = 5;
for (int i : arrayOfInts)
{
if (arrayOfInts[j] == searchFor)
{
break;
}
j++;
}
System.out.println("j = " + j);
```
Break语句也可以在while语句下使用。
```java
int i = 0;
int[] arrayOfInts = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int searchFor = 5;
while(i < 10){
System.out.println("i = " + j);
if(arrayOfInts[i] > 7){
break;
}
}
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CJZC/0)

View File

@ -0,0 +1,51 @@
---
title: Continue Control Statement
localeTitle: 继续控制声明
---
# 继续控制声明
`continue`语句使循环在继续之后跳过所有以下行,并跳转到下一次迭代的开始。在`for`循环中控制跳转到update语句`while``do while`循环中,控制跳转到布尔表达式/条件。
```java
for (int j = 0; j < 10; j++)
{
if (j == 5)
{
continue;
}
System.out.print (j + " ");
}
```
除非等于`5` ,否则将为每次迭代打印`j`的值。由于`continue` 将跳过print语句输出将是
```
0 1 2 3 4 6 7 8 9
```
假设你想要在`mississippi`这个词中计算`i`的数量。在这里,您可以使用带有`continue`语句的循环,如下所示:
```java
String searchWord = "mississippi";
// max stores the length of the string
int max = searchWord.length();
int numPs = 0;
for (int i = 0; i < max; i++)
{
// We only want to count i's - skip other letters
if (searchWord.charAt(i) != 'i')
{
continue;
}
// Increase count_i for each i encountered
numPs++;
}
System.out.println("numPs = " + numPs);
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CJZH/0)
此外,您可以使用标签从嵌套集中选择特定循环以跳到下一次迭代。

View File

@ -0,0 +1,49 @@
---
title: Jump Statements
localeTitle: 跳转声明
---
# 跳转声明
跳转语句是一种[_控制流_](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/flow.html)语句。基本上,您可以使用它们来更改正常执行过程中执行语句的顺序。实质上,这些语句会导致程序控制从下一个预期执行点“跳”到程序中的另一个位置。
以下跳转语句通常与循环一起使用:
* [打破](http://forum.freecodecamp.com/t/java-loops-break-control-statement)
* [继续](http://forum.freecodecamp.com/t/java-loops-continue-control-statement)
当满足条件时,'break'控制语句会跳出循环。这意味着循环的其余部分将不会运行。 例如在下面的循环中如果我达到5则循环中断因此它不会继续。
```java
for(int i=0;i<10;i++){
if(i == 5){ //if i is 5, break out of the loop.
break;
}
System.out.println(i);
}
```
输出:
```
0 1 2 3 4
```
'continue'控制语句是'break'的不太强烈的版本。它只会突破当前的循环实例并继续。在下面的循环中如果i为5则循环继续因此它将跳过下面的print语句并继续前进直到我达到10并且循环停止。
```java
for(int i=0;i<10;i++){
if(i == 5){ //if i is 5, break out of the current instance loop.
continue;
}
System.out.println(i);
}
```
输出:
```
0 1 2 3 4 6 7 8 9
```

View File

@ -0,0 +1,55 @@
---
title: Do...While Loop
localeTitle: 做......循环
---
# 做......循环
`do while`类似于`while`循环,但是在检查给定条件之前,保证语句组至少运行一次。 需要注意的一点是'while'循环是一个退出控制循环。虽然(它不一定会执行),'do while'是一个入口控制循环(它将至少执行一次,即使条件不是真的)。
```java
do
{
// Statements
}
while (condition);
```
## 例
```java
int iter_DoWhile = 20;
do
{
System.out.print (iter_DoWhile + " ");
// Increment the counter
iter_DoWhile++;
}
while (iter_DoWhile < 10);
System.out.println("iter_DoWhile Value: " + iter_DoWhile);
```
输出:
```
20
iter_DoWhile Value: 21
```
**记住** :执行一次代码体之后检查`do-while`循环的条件。
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CJYl/0)
## 行使
你能猜出以下代码片段的输出吗?
```java
int i = 10;
do
{
System.out.println("The value of i is " + i);
i--;
}
while (i >= 10);
```

View File

@ -0,0 +1,85 @@
---
title: For Each Loop
localeTitle: 对于每个循环
---
# 对于每个循环
也称为增强型`for`循环,它是一种非常有用且简单的方法来迭代集合,数组或实现`Iterable`接口的任何对象中的每个项目。
```java
for (object : iterable)
{
// Statements
}
```
该循环被读作“对于`iterable`每个元素(可以是数组,可收集等)”。 `object`类型必须与`iterable`的元素类型匹配。
```java
int[] number_list = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
for (int numbers : number_list)
{
System.out.print(numbers + " ");
// Iterated 10 times, numbers 0,1,2...9
}
```
输出:
```
0 1 2 3 4 5 6 7 8 9
```
rocket [运行代码](https://repl.it/CJYs/0)
将其与传统的`for`循环进行比较:
```java
int[] number_list = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
for(int i=0;i < number_list.length;i++)
{
System.out.print(number_list[i]+" ");
// Iterated 10 times, numbers 0,1,2...9
}
```
输出:
```
0 1 2 3 4 5 6 7 8 9
```
rocket [运行代码](https://repl.it/NJfG/0)
上面的两段代码片段都做了同样的工作,但是,很明显,每个循环都有利于迭代和访问集合的元素(在我们的例子中,数组)更容易。
使用增强的for循环我们不再需要提及循环的起点和终点从而减少OutofBounds错误。 删除了对循环计数器和手动索引的需求,并且改进了代码的可读性。
重要的是要注意对循环内的增强for循环进行迭代变量的更改不会导致原始集合元素的更改。
增强的for循环也可以与多维数组或其他Java集合一起使用。 它与多维数字阵列的使用示例如下所示:
```java
int number_list_new[][]={ { 0, 1, 2},
{ 3, 4, 5},
{ 6, 7, 8} };
// Because 2d arrays are implemented as "arrays of arrays",the first iteration variable iterates
// through 3 such arrays(that is, the 3 rows of testarr[][])
for(int i[] : number_list_new)
{
for(int j : i){
System.out.print(j+" ");
}
}
```
输出:
```
0 1 2 3 4 5 6 7 8
```
rocket [运行代码](https://repl.it/NJhP/0)
在上面的代码片段中, `number_list`是一个数组。如果您不知道这是什么,请不要担心。数组是一个容器对象,它包含固定数量的单个类型的值,但稍后会有更多内容。

View File

@ -0,0 +1,73 @@
---
title: For Loop
localeTitle: 对于循环
---
# 对于循环
`for`循环为您提供了一种迭代一系列值的简洁方法。 基本`for`语句有三个部分:变量初始化,布尔表达式和增量表达式。
```java
for (variable initialization; boolean expression; increment expression)
{
// Statements
}
```
* `initialization` - 初始化循环并在开头只执行一次。
您可以在基本`for`循环声明的第一部分初始化多个相同类型的变量;每个初始化必须用逗号分隔。
* `expression` - 在每次迭代开始时进行评估。如果`expression`计算结果为`true` ,则将执行`Statements`
* `increment` - 每次迭代循环后调用。您可以在此处增加/减少变量的值。确保增量对表达式值有效,以避免无限循环。
使用`for`循环的一种常见方法是如果需要迭代代码特定次数。例如如果要输出数字0-10则将计数器的变量初始化为0然后检查该值是否小于10并在每次迭代后向计数器添加一个。
请注意您将检查该值是否小于10不小于或等于10因为您将计数器设置为0。
```java
for (int iter_For = 0; iter_For < 10; iter_For++)
{
System.out.print(iter_For + " ");
// Iterated 10 times, iter_For 0,1,2...9
}
System.out.println("iter_For Value: " + iter_For);
```
注意将for循环中的变量声明为单个语句也是可以接受的。
```java
for (int iter_For = 0; iter_For < 10; iter_For++)
{
System.out.print (iter_For + " ");
// Iterated 10 times, iter_For 0,1,2...9
}
```
输出:
```
0 1 2 3 4 5 6 7 8 9
iter_For Value: 10
```
添加前50个数字的for循环的另一个例子是这样的。 i ++表示i = i + 1。
```java
int addUntil = 50;
int sum 0;
for (int i = 1; i <= addUntil; i++)
{
sum+=i
}
System.out.println("The sum of the first 50 numbers is: " + 50);
```
![:rocket:](https://forum.freecodecamp.org/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CJYr/0)
### 附加功能
您不能使用数字旧的C风格的语言结构或任何不评估布尔值的内容作为if语句或循环结构的条件。例如你不能说ifx除非x是一个布尔变量。
此外请务必记住布尔表达式在某些时候必须求值为true。否则您的程序将陷入无限循环。

View File

@ -0,0 +1,24 @@
---
title: Loops
localeTitle: 循环
---
# 循环
每当您需要多次执行代码块时,通常会循环 派上用场了。
Java有4种类型的循环
* [而Loop](loops/while-loop)
* [做......循环](loops/do-while-loop)
* [对于循环](loops/for-loop)
* [对于每个循环](loops/for-each-loop)
可以使用以下方法自定义循环行为:
* [控制声明](loops/control-statements)
* [中断控制声明](loops/break-control-statement)
* [继续控制声明](loops/continue-control-statement)
循环的一个特例:
* [无限循环](loops/infinite-loops)

View File

@ -0,0 +1,65 @@
---
title: Infinite Loops
localeTitle: 无限循环
---
# 无限循环
infinte循环是一个循环语句 `for` `while` `do-while` ),它不会自行结束。
循环语句的测试条件决定循环体是否执行。因此始终为真的测试条件将永远继续执行循环体。在infinte循环中就是这种情况。
例子:
```java
// Infinite For Loop
for ( ; ; )
{
// some code here
}
// Infinite While Loop
while (true)
{
// some code here
}
// Infinite Do While Loop
do
{
// some code here
} while (true);
```
通常情况下,如果您的循环无限运行,则该错误不应发生,因为无限循环不会停止并阻止程序的其余部分运行。
```java
for(int i=0;i<100;i++){
if(i==49){
i=0;
}
}
```
上面的循环无限运行因为每次我接近49它都被设置为0.这就是说我永远不会达到100来终止循环所以循环是一个无限循环。
但是在这样的循环中停留的程序将无限期地继续使用计算机资源。这是不合需要的,并且是一种“运行时错误”。
为了防止错误程序员使用break语句来摆脱循环。中断仅在特定条件下执行。使用像if-else这样的选择语句可以保证相同。
```java
while (true)
{
// do something
if(conditionToEndLoop == true)
break;
// do more
}
```
在常规循环上使用无限循环的主要优点是可读性。
有时,如果循环在中间结束,而不是在结束/开始,则循环体更容易理解。在这种情况下,无限循环将是更好的选择。

View File

@ -0,0 +1,42 @@
---
title: While Loop
localeTitle: 而Loop
---
# 而Loop
`while`循环重复执行语句块,直到括号中指定的条件求值为`false` 。例如:
```java
while (some_condition_is_true)
{
// do something
}
```
每个'迭代'(执行语句块)之前都要对括号中指定的条件进行求值 - 只有在条件求值为`true`时才执行语句。如果计算结果为`false` ,则程序的执行将从`while`块之后的语句继续执行。
**注意** :要使`while`循环开始执行,您最初需要条件为`true` 。但是,要退出循环,必须在语句块中执行某些操作,以便在条件计算结果为`false`时最终到达迭代(如下所示)。否则循环将永远执行。 (实际上,它会一直运行直到[JVM](https://guide.freecodecamp.org/java/the-java-virtual-machine-jvm)内存不足。)
## 例
在以下示例中, `expression``iter_While < 10`给出。每次执行循环时,我们将`iter_While`增加`1` 。当`iter_While`值达到`10`时, `while`循环中断。
```java
int iter_While = 0;
while (iter_While < 10)
{
System.out.print(iter_While + " ");
// Increment the counter
// Iterated 10 times, iter_While 0,1,2...9
iter_While++;
}
System.out.println("iter_While Value: " + iter_While);
```
输出:
```
0 1 2 3 4 5 6 7 8 9
iter_While Value: 10
```
![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":火箭:") [运行代码](https://repl.it/CJYj/0)

View File

@ -0,0 +1,89 @@
---
title: Methods
localeTitle: 方法
---
# 方法
Java中最容易识别的方法可能是`public static void main(String[]args)` ,其中`public`表示用户可以访问该方法, `static`表示该方法基于“类”而不是“实例”, `void`表示没有任何东西会从方法返回到另一个(更高级别)方法,而`main`是这个特定方法的名称。
`getName()``getManufacturerName()`是我们在这里使用的两个“Getter”方法。通常Java中的方法包含以下部分 -
* Access Modifer可选 - `public` `private``protected` 。如果省略则默认为package private
* 返回类型 - 这是必需的,它表示方法返回的值,如果没有返回任何值,则返回`void`
* 方法名称 - 遵循camelCase约定
* 参数列表 - 参数列表及其名称和类型,如果没有接受参数,则为空
* 方法体被`{ }`包围
方法也可以选择使用`static`关键字这意味着它与类本身相关联而不是类的实例ex - `public static void main()`
请注意与JavaScript不同我们**必须**定义我们编写的任何方法的返回类型,否则它将在编译时失败。如果您不希望方法返回任何内容,请使用`void` return type。
每个方法都有一个签名,它是数据类型,名称和方法所用参数数量的组合。在`public static void main`该方法没有指定的数据类型,而是使用`void`来声明不返回任何数据。在名为`public static double ave(double val, double val)`的方法中数据类型为“double”0.0名称为“ave”平均值方法采用2个参数。每种方法都**必须**具有唯一的签名。
```java
public class Car {
private String name;
private String manufacturersName;
public void changeName() {
name = "Tesla";
}
public String getName(){
return name;
}
public String getManufacurername(){
return manufacturersName;
}
}
```
参数可以传递给方法。参数在括号内的方法名称后面声明。 参数声明的语法是\[数据类型\] \[名称\]。
```java
public class Car {
private String name;
public void changeName(String newName) {
name = newName;
}
}
```
与任何其他语言一样方法或函数如果您来自JS世界经常用于其模块化和可重用性。
方法通常用于许多目的,例如更新对象中的信息或将数据提供给调用者。这里有些例子。
```java
public class Car {
private int numberOfWheels;
public void setNumberOfWheels(int newNumberOfWheels) {
numberOfWheels = newNumberOfWheels;
}
public int getNumberOfWheels() {
return numberOfWheels;
}
}
```
`getNumberOfWheels()`的情况下,返回类型是`int` ,它是整数。关键字`return`告诉java传回实例变量`numberOfWheels`的值。然而, `setNumberOfWheels(int newNumberOfWheels)`没有返回类型因为它是如前所述的setter方法。在这种情况下虽然它接受`int`类型的参数并使实例变量`numberOfWheels`等于`newNumberOfWheels`
还有一种称为构造函数的特殊方法,允许在实例化类时设置数据或执行操作。此构造函数没有返回类型。
```java
public class Car {
private String model;
private int numberOfWheels;
public Car(String model, int numberOfWheels) {
this.model = model;
this.numberOfWheels = numberOfWheels;
}
}
```
`Car`类和`Car(String model, int numberOfWheels)`方法必须具有相同的名称以便java知道它是构造函数。现在只要您使用`new`关键字实例化新的`Car`实例,就需要调用此构造函数并传入所需的数据。

View File

@ -0,0 +1,35 @@
---
title: Multithreading
localeTitle: 多线程
---
## 多线程
多线程是一个同时执行多个进程的过程。 Java使用主线程启动程序并且只要有任何用户创建它就会在主线程上添加更多线程。主线程是任何Java程序中的第一个用户线程。此外JVM确保在程序结束之前关闭所有用户线程。
线程既有优点也有缺点。
## 好处:
* 独立于其他线程运行代码。
* 创建模块化设计。
## 缺点:
如果线程未正确同步,则会出现竞争条件和死锁。
线程可以进一步分为两类:
* 用户线程
* 守护线程
可以通过两种方式创建线程:
1. 实现Runnable接口 Runnable接口中只有一个方法即public void run。实现此方法将确保每当此线程启动时run内的代码执行。
2. 扩展线程类。 这个类还包含public void run为了运行我们自己的代码我们需要覆盖它们。使用此方法的缺点是我们在Thread中有一个超类并且不能扩展我们可能想要的任何其他类。
两者的代码可以在这里找到http//ide.geeksforgeeks.org/k7GjcA。
您会注意到,如果多次运行此代码,结果可能会有所不同。这是由运行它的操作系统决定的。操作系统可以从可运行状态中选择任何线程并运行它。我们没有控制权。如果有多个线程处于可运行状态(准备运行),则可以挑选任何人。它甚至不依赖于优先权。

View File

@ -0,0 +1,39 @@
---
title: POJO
localeTitle: POJO
---
## POJO
POJO代表“Plain Old Java Object”。这与Plain Old _Javascript_ Objects不同。 Plain Old Java Object指的是Java编程语言中使用的面向对象编程OOP范例。 [OOP模型](https://en.wikipedia.org/wiki/Object-oriented_programming)将数据视为“对象”。每个“对象”都是“类”的一个实例,它表示所有对象从中继承其属性和属性的原型或模板。
因此POJO只是一个Java对象。但是它还必须满足以下附加标准
1. 它不能扩展预先指定的Java类;
```java
public class Foo extends javax.servlet.http.HttpServlet {
...// body ...
}
```
2. 它不得实现预先指定的接口;
```java
public class Bar implements javax.ejb.EntityBean {
... // body
}
```
3. 它不得包含预先指定的注释。
```java
@javax.persistence.Entity public class Baz {
... // body ...
}
```
因此只有在没有上述修改的情况下Java对象才有资格作为POJO。因此遵循正式Java语言规范规定的POJO不受“任何限制”约束。
#### 更多信息:
[维基百科 - POJO](https://en.wikipedia.org/wiki/Plain_old_Java_object)

View File

@ -0,0 +1,11 @@
---
title: Regular Expressions
localeTitle: 常用表达
---
## 常用表达
这是一个存根。 [帮助我们的社区扩展它](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/quadratic-equations/index.md) 。
[这种快速风格指南有助于确保您的拉取请求被接受](https://github.com/freecodecamp/guides/blob/master/README.md) 。
#### 更多信息:

View File

@ -0,0 +1,49 @@
---
title: Resources
localeTitle: 资源
---
# 资源
Java是Oracle的商标和许可。除非由Oracle托管否则以下大部分内容都是非官方资源。
## 教程
* [Oracle官方Java教程](http://docs.oracle.com/javase/tutorial/index.html)
* [想想Java](http://greenteapress.com/wp/think-java/)
* [Jenkov的Java教程](http://tutorials.jenkov.com/java/index.html)
* [Mkyong的Java和Spring教程](http://www.mkyong.com/)
* [Vogella的Java教程](http://www.vogella.com/tutorials/java.html)
* [Java 8教程](https://github.com/winterbe/java8-tutorial)
* [更好的Java](https://github.com/cxxr/better-java)
* [NTU的Java编程说明](http://www3.ntu.edu.sg/home/ehchua/programming/index.html#Java)
* [HackerRank的30天代码挑战与Java视频教程<](https://www.hackerrank.com/domains/tutorials/30-days-of-code)
* [普林斯顿的Java编程入门](http://introcs.cs.princeton.edu/java/home/)
* [使用Java编程简介](http://math.hws.edu/javanotes/)
* [Java实践](http://javapractices.com/home/HomeAction.do)
* [Java设计模式](https://github.com/iluwatar/java-design-patterns/)
* [Java中的算法](https://github.com/pedrovgs/Algorithms)
* [春季官方指南](https://spring.io/guides)
* [TutorialsPoint - Java](http://www.tutorialspoint.com/java/)
* [Java for Small Teams](https://www.gitbook.com/book/ncrcoe/java-for-small-teams/details)
## 挑战
* [Java Koans](https://github.com/matyb/java-koans)
* [编码Bat Java挑战](http://codingbat.com/java)
* [Excercism Java挑战](http://exercism.io/languages/java)
* [项目欧拉](https://projecteuler.net/)
* [练习吧! - Java挑战](http://practiceit.cs.washington.edu/)
* [Codewars - Java Katas](https://www.codewars.com/?language=java)
* [HackerRank Java挑战](https://www.hackerrank.com/domains/java/java-introduction)
* [本文给出了](https://leetcode.com/)
* [CodeAbbey](http://www.codeabbey.com/)
## 社区
* [Oracle Java社区](http://www.oracle.com/technetwork/java/community/index.html)
* [真棒Java](https://github.com/akullpp/awesome-java)
* [/ R / Java的](https://www.reddit.com/r/Java)
* [/ R / LearnJava](https://www.reddit.com/r/learnjava)
* [Java Ranch](http://www.javaranch.com/)
* [Java Code Geeks](https://www.javacodegeeks.com/)
* [Java 8 API搜索](http://javasearch.org)

View File

@ -0,0 +1,132 @@
---
title: Static
localeTitle: 静态的
---
# 静态的
将变量或方法声明为静态时,它属于类,而不是特定实例。这意味着只有一个静态成员实例存在,即使您创建了该类的多个对象,或者您没有创建任何实例。它将由所有对象共享。
static关键字可以与变量方法代码块和嵌套类一起使用。
## 静态变量
**_例_**
```java
public class Counter {
public static int COUNT = 0;
Counter() {
COUNT++;
}
}
```
`COUNT`变量将由该类的所有对象共享。当我们在main中创建Counter类的对象时访问静态变量。
```java
public class MyClass {
public static void main(String[] args) {
Counter c1 = new Counter();
Counter c2 = new Counter();
System.out.println(Counter.COUNT);
}
}
// Outputs "2"
```
outout是2因为`COUNT`变量是静态的并且每次创建Counter类的新对象时都会增加1。您还可以使用该类的任何对象访问静态变量例如`c1.COUNT`
## 静态方法
静态方法属于类而不是实例。因此,可以在不创建类实例的情况下调用它。它用于改变类的静态内容。静态方法有一些限制:
1. 静态方法不能使用类的非静态成员(变量或函数)。
2. 静态方法不能使用`this``super`关键字。
**_例_**
```java
public class Counter {
public static int COUNT = 0;
Counter() {
COUNT++;
}
public static void increment(){
COUNT++;
}
}
```
也可以从类的实例调用静态方法。
```java
public class MyClass {
public static void main(String[] args) {
Counter.increment();
Counter.increment();
System.out.println(Counter.COUNT);
}
}
// Outputs "2"
```
输出为2因为它通过静态方法`increament()`递增。与静态变量类似,也可以使用实例变量访问静态方法。
## 静态块
静态代码块用于初始化静态变量。声明静态变量后立即执行这些块。
**_例_**
```java
public class Saturn {
public static final int MOON_COUNT;
static {
MOON_COUNT = 62;
}
}
```
```java
public class Main {
public static void main(String[] args) {
System.out.println(Saturn.MOON_COUNT);
}
}
// Outputs "62"
```
输出为62因为变量`MOON_COUNT`在静态块中分配了该值。
## 静态嵌套类
一个类可以有静态嵌套类,可以使用外部类名访问它。
**_例_**
```java
public class Outer {
public Outer() {
}
public static class Inner {
public Inner() {
}
}
}
```
在上面的示例中, `Inner`类可以作为类`Outer`的静态成员直接访问。
```java
public class Main {
public static void main(String[] args) {
Outer.Inner inner = new Outer.Inner();
}
}
```
[Builder中](https://en.wikipedia.org/wiki/Builder_pattern#Java)常用的静态嵌套类的一个用例java。

View File

@ -0,0 +1,99 @@
---
title: Streams
localeTitle: 流
---
# 流
在Java 8中Streams被添加为Java工具箱的新功能。 Streams允许您快速干净地处理集合。
在继续之前请阅读有关lambdas和函数式编程的章节。
## 怎么运行的
Stream为您循环集合的元素。 为每个对象调用每个中间和终端操作。 完成第一个对象的所有操作后,将加载第二个对象。
## 重要方法
### 创建
* `Collection.stream()` :从任何实现`Collection`类中的任何对象创建一个Stream
* `Arrays.stream(array)` 从Array创建一个Stream
### 中级操作
这些操作以某种方式转换流对象。
* `Stream.map(Function<In,Out> function)` 应用函数将In转换为Out
* `Stream.filter(Predicate<In> predicate)` 从Stream中删除对象谓词不测试为true
* `Stream.distinct()` 从Stream中删除重复的对象
* `Stream.sorted()` 对Stream中的对象进行排序
* `Stream.limit(int n)` 在n个对象之后的end `Stream.limit(int n)`
### 终端操作
这些操作接收流对象并结束流。
* `Stream.collect(Collector<In,?,Out> collector)` 将Stream中的所有对象收集到Object中
* `Stream.forEach(Consumer<In> consumer)` 使用使用者函数使用Stream中的所有对象
* `Stream.count()` 计算Stream中的所有对象
* `Stream.findFirst()` 返回Stream的第一个Object并停止
* `Stream.anyMatch(Predicate<In> predicate)` 如果Stream中的任何Object对Predicate测试为true则返回true
* `Stream.allMatch(Predicate<In> predicate)` 如果Stream中的所有Object对Predicate测试为true则返回true
## 例子
```java
// print the length of all Strings in a List
for (String string : Arrays.asList("abc", "de", "f", "abc")) {
int length = string.length();
System.out.println(length);
}
Arrays.asList("abc", "de", "f", "abc")
.stream()
.map(String::length)
.forEach(System.out::println);
// output: 3 2 1 3
```
```java
// print all Strings in a List with a Length greater than 2
for (String string : Arrays.asList("abc", "de", "f", "abc")) {
if (string.length() > 2) {
System.out.println(string);
}
}
Arrays.asList("abc", "de", "f", "abc")
.stream()
.filter(string -> string.length() > 2)
.forEach(System.out::println);
// output: abc abc
```
```java
// create a sorted List with all unique Strings from another List which are longer than or requal 2
List<String> result = new ArrayList<>();
for (String string : Arrays.asList("de", "abc", "f", "abc")) {
if (string.length() >= 2
&& ! result.contains(string)) {
result.add(string);
}
}
Collections.sort(result);
List<String> result2 = Arrays.asList("de", "abc", "f", "abc")
.stream()
.filter(string -> string.length() >= 2)
.distinct()
.sorted()
.collect(Collectors.toList());
// result: abc de
```
### 来源
1. [使用Java SE 8 Streams处理数据第1部分](http://www.oracle.com/technetwork/articles/java/ma14-java-se-8-streams-2177646.html)

View File

@ -0,0 +1,140 @@
---
title: Strings
localeTitle: 字符串
---
# 字符串
字符串是字符序列。在Java中 `String`是一个`Object` 。字符串不应与`char`混淆因为字符实际上是1个值而不是字符序列。您仍然可以在String中使用1个值但是在检查1个字符时最好使用`char`
```java
String course = "FCC";
System.out.println(course instanceof Object);
```
输出:
```
true
```
您可以通过以下方式创建String对象
1. `String str = "I am a String"; //as a String literal`
2. `String str = "I am a " + "String"; //as a constant expression`
3. `String str = new String("I am a String"); //as a String Object using the constructor`
你可能会想:这三者有什么区别?
好吧,使用`new`关键字可以保证创建一个新的`String`对象,并在`Heap`分配一个新的内存位置 记忆[(点击这里了解更多)](https://docs.oracle.com/cd/E13150_01/jrockit_jvm/jrockit/geninfo/diagnos/garbage_collect.html) 。串 文本和常量String表达式在编译时缓存。编译器将它们放在String Literal Pool中以防止重复 并改善内存消耗。对象分配很昂贵,这个技巧在实例化字符串时提高了性能。如果你使用 再次使用相同的文字JVM使用相同的对象。使用上面这样的构造函数几乎总是更糟糕的选择。
在此代码段中创建了多少个String对象
```java
String str = "This is a string";
String str2 = "This is a string";
String str3 = new String("This is a string");
```
答案是创建2个String对象。 `str``str2`都指向同一个对象。 `str3`具有相同的内容,但使用`new`强制 创造一个新的,独特的对象。
当您创建String文本时JVM会在内部检查所谓的`String pool` ,以查看它是否可以找到类似的内容(内容明智) 字符串对象。如果找到它则返回相同的引用。否则它只是继续并在池中创建一个新的String对象以便 将来可以进行相同的检查。
您可以使用swallowfast Object comparison `==`和实现的`equals()`来测试它。
```java
System.out.println(str == str2); // This prints 'true'
System.out.println(str == str3); // This prints 'false'
System.out.println(str.equals(str3)); // This prints 'true'
```
这是另一个关于如何使用不同方法在Java中创建字符串的示例
```java
public class StringExample{
public static void main(String args[]) {
String s1 = "java"; // creating string by Java string literal
char ch[] = {'s','t','r','i','n','g','s'};
String s2 = new String(ch); // converting char array to string
String s3 = new String("example"); // creating Java string by new keyword
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
}
}
```
#### 比较字符串
如果要比较两个String变量的值则不能使用==。这是因为这将比较变量的引用 而不是链接到它们的值。要比较字符串的存储值请使用方法equals。
```java
boolean equals(Object obj)
```
如果两个对象相等则返回true否则返回false。
```java
String str = "Hello world";
String str2 = "Hello world";
System.out.println(str == str2); // This prints false
System.out.println(str.equals(str2); // This prints true
```
第一个比较是假的,因为“==”查看引用并且它们不相同。
第二个比较是正确的因为变量存储相同的值。在这种情况下“Hello world”。
我们在String中有几个内置方法。以下是String Length方法的示例。
```java
public class StringDemo {
public static void main(String args[]) {
String palindrome = "Dot saw I was Tod";
int len = palindrome.length();
System.out.println( "String Length is : " + len );
}
}
```
这将导致 - `String Length is : 17`
**答案是:**创建**2个** String对象。 **笔记**
1. String方法使用从零开始的索引`substring()`的第二个参数除外。
2. String类是final - 它的方法不能被覆盖。
3. 当JVM找到String文字时它将被添加到字符串文字池中。
4. String类具有方法名`length()` ,而数组具有属性命名长度。
5. 在java中字符串对象是不可变的。永恒只是意味着不可修改或不可改变。创建字符串对象后无法更改其数据或状态但会创建新的字符串对象。
字符串长度
字符串的“长度”只是其中的字符数。所以“hi”是长度2“Hello”是长度5.字符串上的length方法返回它的长度如下所示
```java
String a = "Hello";
int len = a.length(); // len is 5
```
#### 其他可以在String上使用的比较方法是
1. equalsIgnoreCase - 比较字符串而不考虑区分大小写。
```java
String a = "HELLO";
String b = "hello";
System.out.println(a.equalsIgnoreCase(b)); // It will print true
```
2. compareTo - 按字典顺序比较值并返回一个整数。
```java
String a = "Sam";
String b = "Sam";
String c = "Ram";
System.out.println(a.compareTo(b)); // 0
System.out.prinltn(a.compareTo(c)); // 1 since (a>b)
System.out.println(c.compareTo(a)); // -1 since (c<a)
```

View File

@ -0,0 +1,36 @@
---
title: Java Swing
localeTitle: Java Swing
---
## Java Swing
让我们来探索Java swing教程。在使用Swing弄脏之前建议您浏览[Abstract Window ToolkitAWT](https://www.studytonight.com/java/java-awt.php)之前Swing是作为[Java Foundation ClassesJFC](https://en.wikipedia.org/wiki/Java_Foundation_Classes)的一部分添加的。但是它完全从Java合并到Java中1.2起。
### 极具特色的功能
1. 轻量级组件 - 由于Swing组件完全用JAVA编写因此它们不像AWT组件那样使用特定于平台的资源。
2. 可插拔外观PLAF - 组件的外观完全由Swing本身决定。这使得更容易区分外观和组件的逻辑。
Swing GUI由两个主要支柱组成 - 组件和容器。以下部分详细讨论了它们。
### 组件
Component只是一个独立的可视化控件.Swing组件派生自JComponent类。进一步的JComponent继承了AWT容器和组件的所有特性。有关更多信息请查看[JComponent](https://docs.oracle.com/javase/tutorial/uiswing/components/jcomponent.html)类的层次结构。
### 集装箱
所有容器也是组件。容器可包括一个或多个部件。 Swing定义了两种类型的容器
* 继承自JComponent-例如JFrameJWindowJAppletJDialog
* 不继承自JComponent-例如JPanel
### 包
Swing包含大量软件包。请查看[官方文档](https://docs.oracle.com/javase/7/docs/api/javax/swing/package-use.html)以获取更多信息。
#### 更多信息:
* [Oracle文档](https://docs.oracle.com/javase/7/docs/api/javax/swing/package-use.html)
* [维基百科](https://en.wikipedia.org/wiki/Swing_(Java)

View File

@ -0,0 +1,13 @@
---
title: Java Virtual Machine
localeTitle: Java虚拟机
---
# Java虚拟机JVM
Java属于称为[**Compiled Languages的**](https://en.wikipedia.org/wiki/Compiled_language)一系列[**语言**](https://en.wikipedia.org/wiki/Compiled_language) 。用这种语言编写的任何代码都需要转换编译为中间形式然后主机平台运行代码的OS /平台)可以理解这种形式。
对于Java此中间形式称为**字节码** 然后由称为Java虚拟机JVM的运行时解释。将[**JVM**](https://docs.oracle.com/javase/specs/jvms/se7/html/)视为一个能够完成运行Java代码的艰苦工作的软件。它负责内存分配线程管理垃圾收集等等。除了Java之外它还支持读取能够运行用GroovyScala等语言编写的代码。
在Java中代码被编写并保存为`.java`文件。编译器javac对java文件进行操作并生成等效的字节码 `.class` )文件。 `java`命令现在可以执行存储在`.class`文件中的字节码。稍后会详细介绍。
以下部分描述了Java中编码的一些基本构建块。

View File

@ -0,0 +1,17 @@
---
title: Throw
localeTitle: 扔
---
## 扔
Java throw关键字用于显式抛出异常。您可以通过throw关键字在java中抛出checked或uncheked异常。 throw关键字主要用于抛出自定义异常。
**_例_**
```java
throw new ArithmeticException("/ by zero not permitted");
```
##### 更多资源
[极客的极客](https://www.geeksforgeeks.org/throw-throws-java/)

View File

@ -0,0 +1,32 @@
---
title: Throws
localeTitle: 抛出
---
## 投
Java throws关键字用于声明异常。它向程序员提供了一个信息即可能会出现异常因此程序员最好提供异常处理代码以便保持正常的流程。
**_例_**
```java
import java.io.IOException;
class Testthrows1{
void m()throws IOException{
throw new IOException("device error");//checked exception
}
void n()throws IOException{
m();
}
void p(){
try{
n();
}catch(Exception e){System.out.println("exception handled");}
}
public static void main(String args[]){
Testthrows1 obj=new Testthrows1();
obj.p();
System.out.println("normal flow...");
}
}
```

View File

@ -0,0 +1,66 @@
---
title: tokens
localeTitle: 令牌
---
# Java中的标记
这些是程序的基本构建块或程序的最小单元。 Java支持五种类型的令牌
## 1.关键词
这些是在编译器中具有预定义定义的单词不能用作标识符的名称。在Java中有51个关键字和2个保留字。
## 2.标识符
这些是给予程序的不同组件的各种名称。这些包括变量,方法,类等的名称。它们不能以数字开头,但可以包含数字,字母,下划线,货币符号。
## 3.文学
这些提供了一种在程序中表达特定值的方法。这些是以下类型:
### 数字文字
这些在Java中有三种类型。
* ####整数文字
* ####浮点文字
* ####字符文字
### 布尔文字
这些有两种类型
* \#### true
* \#### false
### 字符串文字
## 4.运营商
这些是用于执行某些操作的特殊符号类型。例如+ - \*/
## 5.分离器
这些包括选项卡,输入,空格键。
##### 现在让我们考虑一个程序
```java
//Printing Hello World
public class Hello
{
public static void main(String args[])
{
System.out.println(Hello World);
}
}
```
源代码包含标记例如_public_ _class_ _Hello_ { _public_ _static_ _void_ _main_ _String_ \[\] _args_ { _System_ _out_ _println_ _“Hello World”_ }}生成的标记·编译成Java字节码能够在解释的java环境中运行。令牌对于编译器检测错误很有用。当令牌没有按特定顺序排列时编译器会生成错误消息。

View File

@ -0,0 +1,25 @@
---
title: Typecasting
localeTitle: 铸字
---
## 铸字
将一种数据类型转换为另一种数据类型称为类型转换。以来 Java是一种面向对象的编程语言支持**继承**和**多态** 超类引用变量很容易指向subClass对象。
当我们将一种数据类型的值分配给另一种数据类型时这两种类型可能彼此不兼容。如果数据类型兼容那么JVM将自动执行称为自动类型转换的转换如果不兼容则需要显式转换或转换它们。
### 类型转换
Java类型转换分为两种类型。
**_1.隐式类型转换_** 这里,当两种类型兼容时,会发生自动类型转换 目标类型大于源类型。 例如。 \`\`\`java int i = 100; 长l = i; //不需要显式类型转换 float f = l; //不需要显式类型转换
```
***2. Explicit Typecasting***
When we assign a larger type value to a variable of smaller type, then we need to perform explicit type casting.
eg.
```
java的 双d = 100.04; long l =longd; //需要显式类型转换 int i =intl; //需要显式类型转换 \`\`\`
#### 更多信息:

View File

@ -0,0 +1,55 @@
---
title: Variables
localeTitle: 变量
---
# 变量
变量存储值。它们是用于在程序中存储文本,数字等数据的最基本实体。
在[Java中](https://github.com/FreeCodeCamp/FreeCodeCamp/wiki/Java) ,变量是[_强类型的_](https://en.wikipedia.org/wiki/Strong_and_weak_typing#Definitions_of_.22strong.22_or_.22weak.22) ,这意味着每当声明变量时都必须为每个变量定义类型。否则,编译器将在[编译时](https://en.wikipedia.org/wiki/Compile_time)抛出错误。因此,每个变量都具有以下之一的关联“ [数据类型](https://guide.freecodecamp.org/java/data-types) ”:
* 基元类型: `int` `short` `char` `long` `boolean` `byte` `float` `double`
* 包装类型: `Integer` `Short` `Char` `Long` `Boolean` `Byte` `Float` `Double`
* 参考类型: `String` `StringBuilder` `Calendar` `ArrayList`等。
您可能已经注意到, **包装类型**的拼写类型与**原始类型**完全相同,但开头的大写字母除外(如**参考类型** )。这是因为包装类型实际上是更一般的参考类型的一部分,但通过[自动装箱和拆箱](https://docs.oracle.com/javase/tutorial/java/data/autoboxing.html)与它们的原始对应物_紧密相关_ 。现在,您只需要知道存在这样的“包装类型”。
通常您可以按照以下语法_声明_ (即创建)变量:< _data-type_ > < _variableName_ >;
```java
// Primitive Data Type
int i;
// Reference Data Type
Float myFloat;
```
您可以将已声明之后或同时当你宣布它被称为_初始化_ 代码_赋值_给变量或任何地方。 symbol **\=**用于相同的。
```java
// Initialise the variable of Primitive Data Type 'int' to store the value 10
int i = 10;
double amount = 10.0;
boolean isOpen = false;
char c = 'a'; // Note the single quotes
//Variables can also be declared in one statement, and assigned values later.
int j;
j = 10;
// initiates an Float object with value 1.0
// variable myFloat now points to the object
Float myFloat = new Float(1.0);
//Bytes are one of types in Java and can be
//represented with this code
int byteValue = 0B101;
byte anotherByte = (byte)0b00100001;
```
从上面的例子可以看出Primitive类型的变量与ReferenceWrapper类型的变量的行为略有不同 - 而Primitive变量_存储_实际值Reference变量_指的_是包含实际值的'object'。 您可以在下面链接的部分中找到更多信息。
# 其他资源
* [数据类型](https://guide.freecodecamp.org/java/data-types)
* [类和对象](https://guide.freecodecamp.org/java/classes-and-objects)