概论：

Java语言的目标

• 面向对象
• 简单化（取消指针和内存管理）
• 解释型、与平台无关（JVM制定字节码的设计规范）
• 多线程（有利于网络上实时交互的生动描述和实现）
• 安全高效（不使用指针和内存释放，避免非法内存操作，编译对代码进行类型和语法检查，执行时校验字节码、代码段格式和规则检查）
• 动态性（允许程序在运行中下载代码段取动态改变程序的状态。）

Java语言实现机制

JVM

Java语言的执行模式时编译加解释，编写好的Java源程序由编译器转换为标准字节码，然后JVM解释执行。JVM运行的代码存储在.class文件中，每个文件包含最多一个public类的代码。

JVM的代码由简洁高效的字节码构成，JVM用字节码程序与各操作系统和硬件分开，保证Java程序独立于平台，而JVM本身可以用软件或硬件实现

JVM具体实现三个任务：

加载代码：由类加载器完成

校验代码：由字节码检验器完成

执行代码：由解释器完成

垃圾回收机制

对内存自动跟踪，对不用的内存自动回收

JRE

Java运行环境

Java语言面向对象编程

基本概念

抽象：面向对象编程的思虑

基本数据类型

标识符：字母，下划线_，美元$作为开头，数字不可作为开头。大小写敏感

关键字：

数据类型：boolean，byte，char，double，false，float，int，instandeof，long，new，null，short，ture，void

表示语句：break,case,catch,continue,default,do,else,for,finally,if,return,switch,super,this,throw,try,while

用于修饰:abstract,final,native,private,protected,public,static,synchronized,transient,volatile

表示方法、类、接口和包：class,extends,implements,import,interface,package,throws

保留未用：const，goto

字符常量

• \'单引号
• \"双引号
• \\反斜杠
• \r回车
• \n换行
• \b退格
• \f走纸换页
• \t横向跳格
• \ddd一至三位八进制数\141为a（ASCII码）
• \uxxxx一至四位十六进制数\u0047为A

数据间转换

Byte、short、char→int→long→float→double

char转换int时

强制类型转换(类型)

short s；

byte b = (byte)s;

wrapper

运算符和表达式

位运算符

• ~：按位取反

• &：按位与

• |：按位或

• ^：按位异或（不同为1，相同为0a）

• >>：按位右移

• <<：按位左移

• >>>：补零按位右移（正数时与>>相同，负数时改变符号，相当于取绝对值后除以2的n次方）

  分支选择语句

package SL4_4;

import java.math.*;

public class SwitchStatement {
	public static void main(String[] args) {
		/* * switch(expression){ * case value1 : statement1; * break; * case value2 :statement2; * break; * } * *value1、value2为定值，不可为表达式 expression取值的类型可为int byte short char * */
		
		int date = (int) (Math.random() * 30) + 1;
		switch (date % 7) {
		case 0:
			System.out.println("本月" + date + "日是星期天");
			break;
		case 1:
			System.out.println("本月" + date + "日是星期一");
			break;
		case 2:
			System.out.println("本月" + date + "日是星期二");
			break;
		case 3:
			System.out.println("本月" + date + "日是星期三");
			break;
		case 4:
			System.out.println("本月" + date + "日是星期四");
			break;
		case 5:
			System.out.println("本月" + date + "日是星期五");
			break;
		case 6:
			System.out.println("本月" + date + "日是星期六");
			break;
		}
	}

}

高级类特性

static

当一个类的变量或方法为static时，只意味着该变量或方法时类变量或类方法，与任何对象无关（独立）

数据：表示所修饰的数据属于类共享的变量或常量。

方法：表示所修饰的方法属于整个类

代码块：表示所修饰的代码块属于该类，而且只进行一次。这种代码块类似实例的初始化程序，但每个类（而非对象）只执行一次，主要用于类的初始化

类：表示特指静态内部类

final

数据：永远不变的常量

方法：不可覆盖的方法

类：不可被继承的类

枚举类型

package EnumDemo;

import java.util.Scanner;

public class EnumTest {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.println("请输入服装号型：（SMALL,MEDIUM,LARGE,EXTRA_LARGE,EXTRA_EXTRA_LARGE）");
		String input = in.next().toUpperCase();
		Size size = Enum.valueOf(Size.class, input);
		System.out.println("abbrevation ="+size.getAbbrevation());
		if(size == Size.EXTRA_LARGE ^ size == Size.EXTRA_EXTRA_LARGE) {
			System.out.println("很好，你注意到了下划线\"_\"");
		}
	}
	
	enum Size{SMALL("S"),MEDIUM("M"),LARGE("L"),
		EXTRA_LARGE("XL"),EXTRA_EXTRA_LARGE("XXL");
	private String abbrevation;
	private Size(String abbrevation) {
		this.abbrevation=abbrevation;
	}
	public String getAbbrevation() {
		return abbrevation;
	}
	
	}

}

抽象类

package AbstractClassDemo;

public abstract class Person {
	private String name;
	public Person(String n){
		name = n;		
	}
	public abstract String getDescription();//没有{}，子类必须实现（重写此方法）
	public String getName() {
		return name;
	}
}

类内可有方法和抽象方法。其中抽象方法子类必须实现（重写）。

抽象类不能有对象。

接口（interface）

public interface stockWatcher{
    final String sunTicker = "SUNW";//只能声明常量
    void valueChanged(String tickerSymbol , double newValue)//只能写抽象方法
}

接口可以作为对象的接收器，但不能实例化：

public class oracle implememn stockWatcher{
    void valueChanged(String tickerSymbol , double newValue){
        
    }
}
public static void main(String[] args) {
    stockWatcher oracle1 = new oracle();//不会报错
}

内部类（嵌套在类内的类）

只能在代码块内使用，如果外部要使用必须给出类的全名。

数组

数组里的元素是引用类型

多维数组：

int intArray[][] = {{11,22,33},{23,56}}//由两个一维数组组成，第一个维数为3，第二个维数为2.

[][]

异常和断言

异常处理类型

捕获异常

try{
    //抛出异常的程序段
}catch(ExceptionName1 e){
    //异常1的处理手段
}catch(ExceptionName2 e){
    //异常2的处理手段
}finally{
    //不管怎样都会执行的程序段
}

package SL6_3;

public class CatchException {
	static void Example(int keg) {
		System.out.println("—————in KegDepartment-----");
		try {
			if(keg == 10) {
				System.out.println("no Exception");
				return;
			}else if(keg == 20) {
				int i = 0;
				int j = 8/i;
			}else if(keg == 30) {
				int iArray[] = new int[4];
				iArray[10] = 3;
			}
		}catch(ArithmeticException e){
			System.out.println("catch"+e);
		}catch(ArrayIndexOutOfBoundsException e) {
			System.out.println("catch"+e.getMessage());	
		}catch(Exception e) {
			System.out.println("Will not beexception");
		}finally {
			System.out.println("in Excmple finally");
		}
	}
	
	public static void main(String[] args) {
		Example(10);
		Example(20);
		Example(30);
	}

}


//结果如下：
/* —————in KegDepartment----- no Exception in Excmple finally —————in KegDepartment----- catchjava.lang.ArithmeticException: / by zero in Excmple finally —————in KegDepartment----- catch10 in Excmple finally */

声明抛出异常

如果一个方法可能会生成一个异常，如果不能确定如何处理此异常（如找不到文件），必须将异常传递给调用方法，由调用它的方法来处理。这时方法用声明异常抛出，让异常对象从调用栈向后传递，直至有相应得到方法来捕捉（catch）它位置。

自定义异常必须为Exception子类