第三节、轻松学Java_流程控制与面对对象编程

流程控制

if…else结构：

package com.test;
public class Test {
	public static void main(String[] args) {
		int x = 30;
		if (x == 10) {
			System.out.print("Value of X is 10");
		} else if (x == 20) {
			System.out.print("Value of X is 20");
		} else if (x == 30) {
			System.out.print("Value of X is 30");
		} else {
			System.out.print("这是 else 语句");
		}
	}
}

输出结果：Value of X is 30

switch语句：

case 语句不是必须包含break 语句。如果没有break 语句，程序会继续执行下一条case 语句，直到遇到break 语句。default 在没有case 语句的值和变量值相等的时候执行。default 分支不需要break 语句。

package com.test;
public class Test {
	public static void main(String[] args) {
		char grade = 'C';
		switch (grade) {
		case 'A':
			System.out.println("优秀");
			break;
		case 'B':
		case 'C':
			System.out.println("良好");
			break;
		case 'D':
			System.out.println("及格");
		case 'F':
			System.out.println("你需要再努力努力");
			break;
		default:
			System.out.println("未知等级");
		}
		System.out.println("你的等级是 " + grade);
	}
}

输出：
良好
你的等级是 C

while与do…while语句：

do…while 循环和while 循环相似，不同的是，do…while 循环至少会执行一次。

package com.test;
public class Test {
	public static void main(String[] args) {
		int x = 1; // 定义变量x，初始值为1
		do {
			System.out.println("x = " + x); // 打印x 的值
			x++; // 将x 的值自增
		} while (x <= 4); // 循环条件
	}
}

输出：
x = 1
x = 2
x = 3
x = 4

for与增强的for语句：

for(声明语句 : 表达式)
{
语句
}
声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。

package com.test;
public class Test {
	public static void main(String[] args) {
		int[] numbers = { 10, 20, 30, 40, 50 };
		for (int x : numbers) {
			System.out.print(x);
			System.out.print(",");
		}
		System.out.print("\n");
		String[] names = { "James", "Larry", "Tom", "Lacy" };
		for (String name : names) {
			System.out.print(name);
			System.out.print(",");
		}
	}
}

输出结果：
10,20,30,40,50,
James,Larry,Tom,Lacy,

跳转语句：

break 语句和continue 语句的区别：break 语句是跳出当前层循环，终结整个循环，也不再判断循环条件是否成立；continue 语句则是结束本次循环，不再运行continue 之后的语句，然后重新回到循环的起点，判断循环条件是否成立，继续运行。

package com.test;
public class Test {
	public static void main(String[] args) {
		int sum = 0; // 定义变量sum，用于记住和
		for (int i = 1; i <= 100; i++) {
			if (i % 2 == 0) { // i 是一个偶数时不累加
				continue; // 结束本次循环
			}
			sum += i; // 实现sum 和i 的累加
		}
		System.out.println("sum = " + sum);
	}
}

输出：
sum = 2500

面对对象编程

类：

[标识符] class 类名
{
类的成员变量
类的方法
}
声明类需要使用关键字class，在class 之后是类名。标识符可以是public、private、protected 或者完全省略。

类中变量的类型：

局部变量。是在方法、构造方法或者语句块中定义的变量。这种变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量。是定义在类中、方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中的方法、构造方法和特定类的语句块访问。
类变量。也声明在类中、方法体之外，但必须声明为static 类型。

类的方法;

修饰符 返回值类型 方法名（参数列表）
{
方法体
return 返回值;
}
方法包含一个方法头和一个方法体。方法头包括修饰符、返回值类型、方法名和参数列表。 修饰符：定义了该方法的访问类型，这是可选的。

package com.test;
class Person {
	String name;
	int age;

	void setName(String name2) {
		name = name2;
	}

	void setAge(int age2) {
		age = age2;
	}

	void speak() {
		System.out.println("我叫" + name + ",今年" + age + "岁。");
	}
}

public class Test {
	public static void main(String[] args) {
	//声明、实例化以及初始化一个类的对象
		Person p1 = new Person();
		p1.setName("张三");
		p1.setAge(18);
		p1.speak();
	}
}

输出：
我叫张三,今年18岁。

类的构造方法

构造方法是一种特殊的成员方法，有以下几下主要特点：

• 构造方法的名称必须与类的名称完全相同。
• 构造方法不返回任何数据，也不需要使用void 关键字声明。
• 构造方法的作用是创建对象并初始化成员变量。
• 在创建对象时，系统会自动调用类的构造方法。
• 构造方法一般用public 关键字声明。
• 每个类至少有一个构造方法。如果不定义构造方法，Java 将提供一个默认的不带参数且方法体为空的构造方法。
• 构造方法也可以重载

package com.test;
class Person {
	String name;
	int age;

	public Person(String name, int age) { // 定义构造方法，有两个参数
		this.name = name;
		this.age = age;
	}

	void speak() {
		System.out.println("我叫" + name + ",今年" + age + "岁。");
	}
}

public class Test {
	public static void main(String[] args) {
		Person p1 = new Person("张三", 18);
		// 根据构造方法，必须含有两个参数，如果不写会报错
		// 为了避免这种情况，应该再添加一种无参数的构造方法：public Person() { }
		// 也就是说，如果自定义了构造方法，为了避免出错
		// 应该定义一个无参数的构造方法，这样也实现了构造方法的重载
		p1.speak();
	}
}

输出：我叫张三,今年18岁。

对象的值传递和引用传递

Java中没有指针，所以没有引用传递，仅仅只有值传递。不过可以通过对象的方式来实现引用传递

package com.test;
public class Test {
	public static void change(int i, int j) {
		int temp = i;
		i = j;
		j = temp;
	}

	public static void main(String[] args) {
		int a = 3;
		int b = 4;
		change(a, b);
		System.out.println("a=" + a);
		System.out.println("b=" + b);
	}
}

输出：
a=3
b=4
这里只是相互的赋值操作，没有改变原来的值。

package com.test;
class A { // 定义一个类
	int i = 0;
}

public class Test {
	public static void add(A a) {
		a.i++;
	}

	public static void main(String args[]) {
		A a = new A();
		add(a);
		System.out.println(a.i);
	}
}

输出：1