Java· 第五周

//第五周实验做第三章1-3题

---

第一章

学习目标：了解Java语言的特点；掌握Java开发环境的搭建；掌握环境变量的配置；理解Java的运行机制；掌握eclipse开发工具的基本使用

Java语言主要面向Internet编程

最主要的特点：

简单性：

        丢弃了C++中的运算符重载、多重继承等模糊概念；

        不用指针，使用引用；

        提供自动的垃圾回收机制

面向对象性：

        提供了类、接口和继承等原语。为了简单起见，只支持类之间的单继承。但支持接口之间的多继承，并支持类与接口之间的实现机制（关键词为implements）。Java语言全面支持动态绑定。

安全性：

        不支持指针，一切对内存的访问都必须通过对象的实例变量来实现

跨平台性：

        程序本身跨平台，但虚拟机不能跨平台

支持多线程：

        程序中有多个任务可以并发执行，提高程序的执行效率

JDK为SUN公司提供的Java开发环境，包括Java编译器、Java运行工具、Java文档生成工具、Java打包工具等

JDK安装目录的子目录介绍：

        bin目录：存放一些可执行程序

                其中最重要的就是javac.exe和java.exe

                        javac.exe是Java编译器工具，可以将编写好的Java文件编译成Java字节码文件（可执行的Java程序）。如源文件"HelloWorld.java"编译后生成"HelloWorld.class"

                        java.exe是Java运行工具，会启动一个Java虚拟机（JVM）进程。Java虚拟机相当于一个虚拟的操作系统，专门负责运行由Java编译器生成的字节码文件（.class文件）

        db目录：一个小型的数据库

        jre目录：Java程序运行时环境的根目录，包含Java虚拟机，运行时的类包、Java应用启动器及一个bin目录，单不包含开发环境中的开发工具

        include目录：由于JDK是通过C和C++实现的。这里存放C语言的一些头文件

        lib目录：Java类库或库文件，是开发工具使用的归档包文件

·        src.zip文件：src文件的压缩包，放置的是JDK核心类的源代码，通过该文件可以查看Java基础类的源代码

class HelloWorld{
    public static void main(String[] args){
        System.out.println("hello world!");
    }
}

其中，class是一个关键字，用于定义一个类（约同一个程序）

HelloWorld是类的名称，与关键字间用任意的空白字符进行分隔即可

public static void main(String[] args){} 定义了一个 main方法，为程序的执行入口

（第一章到此结束，关于直接在win上运行Java程序的部分未整理）

---

第二章 Java编程基础

学习目标：掌握Java基本语法、常量、变量、流程控制语句、方法以及数组；熟悉Java运算符的使用；了解Java代码的基本格式

1.类需要用class关键字定义，class之前可以有一些修饰符：

修饰符 class 类名{
    程序代码
}

2.编写代码注意事项

3.文档注释以"/**"开头，以"*/"结尾

4.标识符定义规则

 5.关键字：

6.数据类型种类

1）整数类型变量

2）浮点数类型变量

         其中，float需要在赋值的后面加上f，double的可以不加

3）字符类型变量

        用char表示，每个占2字节，0~65535范围内的整数会被对应转换

4）布尔类型，boolean

        只有true和false两个值

7.数据类型转换

1）自动转换

 2）强制类型转换

格式：目标类型     变量  =   （目标类型）值

变量在表达式中进行运算时，也有可能发生自动类型转换，这就是表达式数据类型的自动提升，如一个byte型的变量在运算期间类型会自动提升为int型，故而下式需要用到进行强制类型转换

	public static void main(String[] args) {
		byte b1 = 3; // 定义一个byte类型的变量
		byte b2 = 4;
		byte b3 = (byte) (b1 + b2); // 两个byte类型变量相加，赋值给一个byte类型变量
		System.out.println("b3=" + b3);
	}

8.变量的作用域：变量所被定义的大括号内的部分

9.算数运算符

1） 

2)

3) 

4)

5)运算符优先级

10.选择结构语句

1)if语句

if...else

if...else if...else

2)switch case语句：

switch(表达式){
        case 目标值1:
        执行语句 1
        break;
        case 目标值2:
        执行语句 2
        break;
        ......
        case 目标值n:
        执行语句 n
        break;
        default:
        执行语句n+1
        break;
}

                                     

 3)while语句（重复进行条件判断，只要成立，即执行语句）

do ... while

 4)for语句；

5)跳转语句：break，continue

break语句：

        用在switch条件语句和循环语句中，它的作用是终止某个case并跳出switch结构

        当break语句出现在嵌套循环的内层时，它只能跳出内层循环，如果想跳出外层循环，则需要对外层循环添加标记。

public static void main(String[] args) {
		int i, j; // 定义两个循环变量
		itcast: for (i = 1; i <= 9; i++) { // 外层循环
			for (j = 1; j <= i; j++) { // 内层循环
				if (i > 4) { // 判断i的值是否大于4
					break itcast; // 跳出外层循环
				}
				System.out.print("*"); // 打印*
			}
			System.out.print("\n"); // 换行
		}
	}

continue语句：

        用在循环语句中，它的作用是终止本次循环，执行下一次循环 

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);
	}

*11.方法

1)在Java中，声明一个方法的具体语法格式如下：

修饰符 返回值类型 方法名([参数类型 参数名1,参数类型 参数名2,..]) {
			执行语句
			...
			return 返回值;
		}

2)

*12.数组的定义

int[] x=new int[2];

即：
int[] x;
x = new int[2];

//初始值都是0

//二维数组定义
int[][] arr=new int[3][4];//每个元素的长度确定时
int[][] arr=new int[3][];//数组中每个元素的长度不确定时

在程序中可以通过“数组名.length”的方式来获得数组的长度，即元素的个数。

（第二章到此结束）

---

第三章 面向对象（上）

学习目标：掌握列的封装特性、构造方法定义、重载以及this和static关键字的使用；了解面向对象的三大特征；熟悉类与对象的创建和使用

1.面向对象的特点：
1）封装性

2）继承性：无需编写原有类的情况下对原有类的功能进行扩展

3）多态性：允许出现重名现象

2.类的定义

 1)定义完类后，需要继续根据类创建实例对象

类名 对象名称 = new 类名()

eg:
Person p = new Person();
//Person p:声明了一个Person类型的变量p
//new Person():用于创建一个Person类的实例对象
//=:用于键Person对象在内存中的地址赋值给变量p

2)案例 

//例如下列案例
package example3;

class Person{
	int age;
	void speak() {
		System.out.println("我"+age+"岁了");
	}
}

public class e1_1 {
	public static void main(String[] args) {
		Person a = new Person();
		Person b = new Person();
		a.age=18;
		a.speak();
		b.speak();
	}
}

3.类的封装 

 案例：

package example3;
class Student {
	private String name; // 将name属性私有化
	private int age; // 将age属性私有化

	// 下面是公有的 getXxx 和 setXxx 方法
	public String getName() {
		return name;
	}

	public void setName(String stuName) {
		name = stuName;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int stuAge) {
		// 下面是对传入的参数进行检查
		if (stuAge <= 0) {
			System.out.println("对不起，您输入的年龄不合法...");
		} else {
			age = stuAge; // 对属性赋值
		}
	}

	public void introduce() {
		System.out.println("大家好，我叫" + name + ",我今年" + age + "岁!");
	}
}
public class e4 {
	public static void main(String[] args) {
		Student stu = new Student();
		stu.setAge(30);
		stu.setName("韩强");
		stu.introduce();
	}
}

4.构造方法

1)方法名与类名相同；方法名前没有返回值类型的声明；在方法中不能使用return语句返回一个值，但是可以单独写return语句来作为方法的结束

class Person {
	// 下面是类的构造方法
	public Person() {
		System.out.println("无参的构造方法被调用了...");
	}
}

public class Example05 {
	public static void main(String[] args) {
		Person p = new Person(); // 实例化 Person对象
	}
}

2)构造方法的重载

class Person {
	int age;

	// 定义有参的构造方法
	public Person(int a) {
		age = a; // 为age属性赋值
	}

	public void speak() {
		System.out.println("今年我已经 " + age + "岁了!");
	}
}

public class Example06 {
	public static void main(String[] args) {
		Person p = new Person(20); // 实例化 Person 对象
		p.speak();
	}
}

5.this关键字

 6.垃圾回收机制

 7.静态变量（static修饰的成员变量）

1)被所有实例所共享

2)可以使用“类名.变量名”的形式来访问：

package cn.itcast.chapter03.example13;
/**
 * 静态方法的使用
 */
class Person {
	public static void sayHello() { // 定义静态方法
		System.out.println("hello");
	}
}

class Example13 {
	public static void main(String[] args) {
		//1.类名.方法的方式调用静态方法
		Person.sayHello();
		//2.实例化对象的方式来调用静态方法
		Person p = new Person();
		p.sayHello(); 
	}
}

3)静态方法（不和对象绑在一起）

在类汇总定义的方法前加上static关键字即可；可以用“类名.方法名”的方式来访问，也可以通过类的实例对象来访问

4)成员内部类

 

 （第三章到此结束，关于静态代码块的部分没整理）