Java快速入门
Java快速入门
创建一个工程
首先，我们使用Eclipse（注意就是Eclise，如果没有安装好，先安装好再接着下一个步骤）创建一个新的项目，这将在本教程中使用。
输入项目名称：BasicJavaTutorial
项目已创建：
注：为了能够在除英语工程其他语言可以使用，应该切换到UTF-8编码。
右键单击该项目并选择属性：
原始数据类型
JAVA中有八种基本类型
-
对于整数有4种类型：byte, short, int, long
-
实数类型： float, double
-
字符类型： char
-
布尔： 返回 true 或 false 值 (true 或 false)
变量
选中src右键 选择 “New"再选择"Package”:
新建命名包是：com.cactusdi.damo
选择上面创建的包名 com.cactusdi.damo，右击在弹出的菜单中选择 New 中选择 Class。
输入类的名称：Damo
Damo.javapublic static void main(String[] args) { // 声明int类型的变量（整数32位） int firstNumber; // 将值分配给firstNumber firstNumber = 10; System.out.println("First Number =" + firstNumber); // 声明一个32位实数（浮点数）,该数字的值为10.2 float secondNumber = 10.2f; System.out.println("Second Number =" + secondNumber); // 声明一个64位实数,该数字的值为10.2 // 字符d最后告诉Java这是double类型,区别于浮动。 double thirdNumber = 10.2d; System.out.println("Third Number =" + thirdNumber); // 声明一个角色 char ch = 'a'; System.out.println("Char ch= " + ch);}
运行类 Damo:
在 Damo类右键选择 “Run As/Java Application”
运行类，在控制台上看到的结果如下：
控制流
if-else语句
if-else 语句的结构是：
if(condition1 true) {
// Do something here
}elseif(condition2 true) {
// Do something here
}elseif(condition3 true) {
// Do something here
}else { // Other
// Do something here
}
创建一个类 ElseIfExample1:
public static void main(String[] args) {
int score = 20;
System.out.println("Your score =" + score);
if (score < 50) {
System.out.println("You are not pass");
}else if (score >= 50 && score < 80) {
System.out.println("You are pass");
}else {
System.out.println("You are pass, good student!");
}
}
运行 ElseIfExample1 类的结果：
改变在上面的例子中，变量“score”的值，然后重新运行ElseIfExample1类：
int score = 80;
常规操作符
- 大于号>
- 小于号 <
- 大于或等于 >=
- 小于或等于 <=
- 且 &&
- 或 ||
- 等于一个值==
- 不等于一个值 !=
- 非 !
创建一个类 ElseIfExample2
public static void main(String[] args) {
int age = 20;
if (age <= 17) {
System.out.println("You are 17 or younger");
} else if (age == 18) {
System.out.println("You are 18 year old");
}else if (age > 18 && age < 40) {
System.out.println("You are between 19 and 39");
} else {
if (age != 50) {
System.out.println("You are not 50 year old");
}
if (!(age == 50)) {
System.out.println("You are not 50 year old");
}
if (age == 60 || age == 70) {
System.out.println("You are 60 or 70 year old");
}
}
}
可以修改 “age” 的值，然后重新运行 ElseIfExample2 类，并查看结果。
布尔值
布尔是一种数据类型，它只有两个值true或false。
创建一个类 BooleanExample
public static void main(String[] args) {
// 声明boolean类型的变量
boolean value = true;
// 如果值为true
if (value == true) {
System.out.println("It's true");
} else {
System.out.println("It's false");
}
// 使用布尔值，您也可以编写
if (value) {
System.out.println("It's true");
}else {
System.out.println("It's false");
}
}
switch- case -default 语句
这也是类似上面介绍的 if-else 分支语句：
switch( variable_to_test ) {
casevalue:
// code_here;
break;
casevalue:
// code_here;
break;
default:
// values_not_caught_above;
}
public static void main(String[] args) {
// 声明变量年龄
int age = 20;
//检查年龄的值
switch (age) {
// 年龄= 18岁
case 18:
System.out.println("You are 18 year old");
break;
// 年龄= 20岁
case 20:
System.out.println("You are 20 year old");
break;
// 其他
default:
System.out.println("You are not 18 or 20 year old");
}
}
运行类 的结果 :
You are 20 year old
请注意case语句是一个特定的值，不能做下面的操作：
//这是不允许的!!
case(age < 18) :
// case仅接受特定值，例如
case18:
// Do something here
break;
for循环
语法：
for( start_value; end_value; increment_number ) {
// Code here
}
例子:
public static void main(String[] args) {
intstep = 1;
// 声明一个变量值，起始值为0,每次迭代后，值将增加3,当值大于或等于10时，循环将结束
for(intvalue = 0; value < 10; value = value + 3) {
System.out.println("Step ="+ step + " value = "+ value);
// 增加1
step = step + 1;
}
}
运行结果：
Step =1 value = 0
Step =2 value = 3
Step =3 value = 6
Step =4 value = 9
另一实例,从1至100的数字求和：
public static void main(String[] args) {
int sum = 0; for (int i = 0; i <= 100; i = i + 1) {
sum = sum + i;
}
System.out.println(sum);
}
结果：5050
while循环
这是 while 循环结构：
//当 条件为真，do something
while( 条件为真 ) {
// Do something here.
}
例如:
public static void main(String[] args) {
int value = 3;
// 当值小于10时，循环
while( value < 10) {
System.out.println("Value = "+ value);
//通过+2来增加值
value = value + 2;
}
}
do-while循环
下面是do-while循环的结构：
//do-while循环至少一轮; 如果条件为真，继续循环
do{
// Do something here.
}while( 条件 );
示例:
public static void main(String[] args) {
int value = 3;
//do-while循环至少执行一次
do {
System.out.println("Value = " + value);
// +3
value = value + 3;
} while (value < 10);
}
结果：
Value = 3
Value = 6
Value = 9
Java数组
数组是元素存储在彼此相邻列表。
在Java中声明数组。
//声明一个数组，而不是指定数量的元素
int[] array1;
//使用100个元素初始化数组, 该元素尚未分配特定值
array1 = newint[100];
// 声明一个数组指定元素的数量,该元素尚未分配特定值
double[] array2 = newdouble[10];
// 声明一个数组，其元素被赋予特定的值,这个数组有4个元素
long[] array3= {10L, 23L, 30L, 11L};
示例:
public static void main(String[] args) {
// 声明一个包含5个元素的数组
int[] myArray = new int[5];
// 注意：数组索引的第一个元素是0：
//将值分配给第一个元素（索引0）
myArray[0] = 10;
// 将值分配给第二个元素（索引1）
myArray[1] = 14;
//以此类推
myArray[2] = 36;
myArray[3] = 27;
//第5个元素的值（数组中的最后一个元素）
myArray[4] = 18;
// 打印元素计数
System.out.println("Array Length=" + myArray.length);
//索引3打印到控制台（数组中的第4个元素）
System.out.println("myArray[3]=" + myArray[3]);
//使用for循环打印出数组中的元素
for (int index = 0; index < myArray.length; index++) {
System.out.println("Element " + index + " = " + myArray[index]);
}
}
结果：
Array Length=5
myArray[3]=27
Element 0 = 10
Element 1 = 14
Element 2 = 36
Element 3 = 27
Element 4 = 18
类, 继承, 构造器
当我们讨论树，它是抽象的东西，它是一个类。但是，当我们指出了一个特定的树（比如：槟榔树），很明显，那就是实例。
或者，当我们谈论的人，这是抽象的，它是一个类。但是，当指向你或我，这是两种不同的情况下，都是同一个 Person 类。
Person.java
public class Person {
// “名称”字段
public String name;
// 这是一个有一个参数的构造函数,用它来初始化对象（创建新对象）
// 构造函数始终与类具有相同的名称
public Person(String persionName) {
//将参数的值分配到“名称”字段中
this.name = persionName;
}
// 此方法返回一个String
public String getName() {
return this.name;
}
}
Person类没有任何main函数。 TestPerson类通过构造函数初始化Person对象实例
PersonTest.java
public class PersonTest {
public static void main(String[] args) {
// 创建Person类的对象
// 通过类Person的构造函数初始化此对象
// 具体来说Edison
Person edison = new Person("Edison");
// Class Person的方法是getName（）
// 使用该对象调用getName（）：
String name = edison.getName();
System.out.println("Person 1: " + name);
//创建Person类的对象
// 通过类Person的构造函数初始化此对象
// 具体来说Bill Gates
Person billGate = new Person("Bill Gates");
// 班级人员有字段名称（public）
// 使用对象来引用它
String name2 = billGate.name;
System.out.println("Person 2: " + name2);
}
}
运行示例的结果如下：
Person 1: Edison
Person 2: Bill Gates
字段
一般字段
public String myValue;
静态字段
public static int MY_STATIC_FIELD = 100;
final字段, static final 字段
// final字段不允许分配新值
public final int myValue = 100;
// 静态final字段.不允许分配新值
public static final long MY_LONG_VALUE = 1234L;
方法
方法 静态方法 final 方法 (将在类的继承中说明)
MethodSample.java
public class MethodSample {
public String text = "Some text";
// 默认构造函数
public MethodSample() {
}
// 此方法返回一个String,无参
public String getText() {
return this.text;
}
// 这是一个带有一个参数String的方法;此方法返回void（不返回任何内容
public void setText(String text) {
//this.text对文本字段的引用,区分文本参数
this.text = text;
}
// 静态方法
public static int sum(int a, int b, int c) {
int d = a + b + c;
return d;
}
}
MethodSampleTest.java
public class MethodSampleTest {
public static void main(String[] args) {
// 创建MethodSample的实例
MethodSample obj = new MethodSample();
// 调用getText（）方法
String text = obj.getText();
System.out.println("Text = " + text);
// 调用方法setText（String）
obj.setText("New Text");
System.out.println("Text = " + obj.getText());
// 可以通过类调用静态方法,建议采用这种方式（**）
int sum = MethodSample.sum(10, 20, 30);
System.out.println("Sum 10,20,30= " + sum);
// 或者通过对象调用,不推荐这种方式（**）
int sum2 = obj.sum(20, 30, 40);
System.out.println("Sum 20,30,40= " + sum2);
}
}
执行上面的程序输出结果如下：
Text = Some text
Text = New Text
Sum 10,20,30= 60
Sum 20,30,40= 90
在Java中的继承
Java允许从其他类扩展类。类扩展另一个类称为子类。 子类必须有继承父类中的字段和方法的能力。
Animal.java
public class Animal {
public Animal() {
}
public void move() {
System.out.println("Move ...!");
}
public void say() {
System.out.println("");
}
}
Cat.java
public class Cat extends Animal {
// 覆盖Animal类的方法.
public void say() {
System.out.println("I am Cat");
}
}
Dog.java
public class Dog extends Animal {
// 覆盖Animal类的方法
public void say() {
System.out.println("I am Dog");
}
}
Ant.java
public class Ant extends Animal {
}
AnimalTest.java
public class AnimalTest {
public static void main(String[] args) {
// 声明Cat对象
Cat cat = new Cat();
// 检查Animal的'cat'实例,结果为true
boolean isAnimal = cat instanceof Animal;
System.out.println("cat instanceof Animal?"+ isAnimal);
// 调用Cat的方法say()
cat.say();
// 声明一个对象Animal,通过Cat的构造函数初始化对象
Animal cat2 = new Cat();
// 调用Cat的方法say()
cat2.say();
// 创建对象Animal,通过Ant类的构造函数
Animal ant = new Ant();
// Ant没有say（）方法
// 它调用从父类继承的say（）方法（Animal）
ant.say();
}
}
运行示例的结果如下：
cat instanceof Animal?true
I am Cat
I am Cat