/

概述

构成：

JDK、JVM、JAR
JDK，javadevelopmentkit
JVM，javavirtual machine
JAR，java runtime Environment

JDK（Java Development Kit）：

1，即java语言的软件开发工具包，JDK是整个java开发的核心，它包含了JAVA的运行环境（JVM+Java系统类库）和JAVA工具。
2，SE(J2SE)，standard edition，标准版，是我们通常用的一个版本，从JDK 5.0开始，改名为Java SE。

jdk文件目录

bin：存放java启动命令及其开发工具命令（如javac），
db：纯java开发的数据据库Derby，是一个开源的纯java开发的关系型数据库
include：C语言头文件，支持用java本地接口和java虚拟机的接口来实现本机代码编程
jre：JDK自含JRE的根目录，这是系统属性java.home所指向的目录，目录文件如下：
lib：开发工具所使用的文件。

java命名规则：

标识符可以是以任意大小写入字母、数字、下划线、美元符号组成。
但是不可以以数字开头，且严格区分大小写，不能是java的关键字

package关键字：用于生命包
import关键字：用于导入包，一般在package之后

面向对象（OOP）
三大特征，封装、继承、多态

Java中的常量及类型
定义：一些固定不变量
整型常量：整数类型的常量，表现形式有二进制十进制十六进制
字符常量：一个字符
浮点数常量
字符串常量
布尔常量：true/false
null常量：null

Java中的变量
定义：保存程序产生的临时数据的内存单元的标识符
int x=0，y；：定义了两个变量x和y，分配了两个内存单元。x初始值为0，y的初没有分配初始值
y=x+3；：取出x的值并与3相加再赋值给y
Java变量的数据类型

4种整型

注释：java中所有的数据类所占据的字节数量与平台无关，java也没有任何无符号类型

2种浮点类型

三、1种Unicod编码的字符单元
char 2 字节 整个Unicode字符集

四、1种真值类型
boolean 1 位 True或者false

3种引用类型

类class

接口interface

数组array

类Class引用
可以是我们创建的，这里我不多讲，主要是讲解几个java库中的类

Object ：Object是一个很重要的类，Object是类层次结构的根类，每个类都使用Object作为超类，所有对象（包括数

组）都实现这个类的方法。用Object可以定义所有的类

如：

Object object= new Integer(1); 来定义一个Interger类

Integer i=(Integer) object; 在来把这个Object强制转换成Interger类

String ：String类代表字符串，Java 程序中的所有字符串字面值（如”abc”）都作为此类的实例来实现。检查序列的单
个字符、比较字符串、搜索字符串、提取子字符串、创建字符串副本、在该副本中、所有的字符都被转换为大写或小写形式。

Date ：Date表示特定的瞬间，精确到毫秒。Date的类一般现在都被Calendar 和GregorianCalendar所有代替

Void ：Void 类是一个不可实例化的占位符类，它保持一个对代表 Java 关键字 void 的 Class 对象的引用。

同时也有对应的Class如：Integer Long Boolean Byte Character Double Float Short

二、接口interface引用
可以是我们创建的，这里我不多讲，主要是讲解几个java库中的接口interface

List：列表 ，此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引

（在列表中的位置）访问元素，并搜索列表中的元素。List 接口提供了两种搜索指定对象的方法。从

性能的观点来看，应该小心使用这些方法。在很多实现中，它们将执行高开销的线性搜索。 List 接

口提供了两 种在列表的任意位置高效插入和移除多个元素的方法。

add() : 在列表的插入指定元素。

remove()：移除列表中指定位置的元素。

get(int index)：返回列表中指定位置的元素。

Map：

K - 此映射所维护的键的类型

V - 映射值的类型 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

put(K key,V value)：
将指定的值与此映射中的指定键关联（可选操作）。如果此映射以前包含一个该键的 映射关系，则用指定值替换旧值（当且仅当，返回 true 时，才能说映射 m 包含键 k 的映射关系）。

remove(Object key)：
如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。更确切地讲，如果此 映射包含从满足(key==null ? k==null :key.equals(k))的键 k 到值 v 的映射关系，则移除该映射关系。（该映 射最多只能包含一个这样的映射关系。）
get(Object key)：返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
这里我们主要是用String List Map Object 是最常用Number ArrayList Arrays等
可以查考jdk的api这些类和接口在java.lang ：提供利用 Java 编程语言进行程序设计的基础类。

和

java.unit：包含 collection 框架、遗留的 collection 类、事件模型、日期和时间设施、国际化和各种实用工具类（字 符串标记生成器、随机数生成器和位数组）。

变量的数据转换
格式：目标类型变量=（目标类型）值
自动转换：小变大
强制转换：大变小

变量的作用域：变量被定义的第一个大括号中便是变量的作用域

Java中的运算符
算数运算符：
包含：
1，除法运算，整数之间得到结果为整数（忽略小数部分），有小数参与则为结果为小数
2，取模（%）运算时，所得结果正负取决于被模数（%左边的数字）。与模数无关
赋值运算符：
包含：
顺序：从右到左
1，可以通过一条语句对多条多个变量进行赋值
int x，y，z；x=y=z=5；（int x=5=10 是错误的）
2，x+=3意思是，x=x+3，首先进行加法运算。
3，在使用+=、-=、等特殊赋值运算符的时候强制转换类型会自动完成不需要显示地说明
比较运算符：
返回一个布尔类型
逻辑运算符
返回布尔值
&与&&区别。&会对两边进行计算。&&当左边为false的时候则进行计算（||反之亦然）
位运算符

选择结构语句
if
if..else
if…else if
switch：

三元表达式
判断条件？表达式1：表达式2

循环语句
while（）{}
do{} while（）{}
for（初始表达式；循环语句；操作语句）{}

跳转语句：
break：
1，跳出case
2，跳出内循环
3，itcase标记外循环，break itcase跳出外循环
continue：
1，终止本次循环执行下一次循环
2，itcase标记，终止本次外循环

Java中的方法
定义：以前也叫函数，相当于把某个动作疯传成一个可以多次使用的模具
格式：
修饰符返回值类型方法名（参数类型参数名，参数类型参数名）
{
执行语句

return
}
方法的重载
java中允许方法名相同而参数不同的的方法存在
方法的递归：方法的内部调用，必须有结束条件
面向对象：
特点：封装性、继承性、多态性

类：描述一组对象的共同特征和行为
类中包含成员，可以分为成员变量和成员方法，成员用于描述对象特征。即属性。成员方法用于描述行为，简称方法。

对象的创建和使用

对象的实例化
类名对象名new类名（）；
Person p =new Person（）；
p是一个Person类型的变量。
实例化过程中会自动调用构造方法

对象的引用
对象的引用（变量）.对象成员

当一个变量为空时表示该变量不指向任何对象。、
当一个变量被实例化后没有被任何变量引用则会成为垃圾变量

类的封装
private关键字修饰的属性只能在其所在类中被访问。（可以使用Public 修饰的公有方法获得私有属性）

构造方法：
1，方法名与类名相同
2，没有返回值类型的声明
3，不能使用return返回一个值
4，定义一个类时尽量定义一个无参的构造方法
5，如publicAnimal（int a）/public Animal（）
构造方法的重载
1，每一个类中至少含有一个构造方法。系统会自动生成一个构造方法，但是如果定义了有参数的构造方法则系统不会再自动构造所以需要手动添加一个
2，构造方法一般会使用public修饰

this关键字
1，this.变量：可以在重名的方法中访问成员变量
2，this.方法：访问成员方法，可以省略
3，可以在构造函数中使用this([参数1，参数2…])注：必须位于第一行，只能在构造方法中使用，且不能在两个类中使用this相互调用

static关键字
静态变量
1，使用static修饰的成员变量该变量称为静态变量，可以被所用实例共享，可使用类名.变量名调用不需要创建实例对象
2，只能修饰全局变量

静态方法
1，可以不创建对象调用
2，方法内只能调用static修饰的成员

静态代码块
static{}包裹着的代码块。只执行一次通常用于成员的初始化

单例模式
定义：只能被实例化一次的类，只存在一个实例对象
特点：
1，无参的构造函数应用private修饰防止外部使用new关键字实例化
2，在类的内部创建一个该类的实例对象并使用静态变量INSTATNCE引用该对象，使用private修饰。声明为私有对象
3，定义一个静态方法getInstance()用于返回该实例，方法是静态的

内部类：在一个类的内部定义的类，分为成员内部类，静态内部类，方法内部类
成员内部类：
1，可以在外部类中使用并且可以访问外部类的成员
2，外部类访问内部类，需要通过外部类对象创建内部类对象。
格式：外部类名.内部类名变量名=new外部类（）.new 内部类名（）
3，如果内部类被声明为私有则外部类无法访问

静态内部类
1，可以在不创建外部类对象的情况下创建内部类对象
2，只能访问外部类的静态对象、
3，非静态内部类不可以再内部类中定义静态变量

方法内部类
1，只能在当前方法中被使用
2，可以访问外部类成员

类的继承
1，只支持单继承
2，一个类可与被多个类集成
3，允许多重继承
4，使用关键字extends
5，子类在实例化的过程中会自动调用子类的构造方法和父类的构造方法
重写父类的方法
1，需要有相同的方法名参数列表返回值类型，满足条件自动重写。
2，子类重写父类，不能使用比父类更严格的权限
3，子类重写父类方法之后，子类对象就无法调用子类的重写方法。调用时不会调用父类的方法

super关键字
1，使用super关键字调用父类的成员变量和成员方法：super.成员变量/super.成员方法（参数1，参数2）
2，调用父类构造方法：super（参数1，参数2）
3，可以使用super指定在super关键字中对调用父类哪个构造方法（五指定会默认调用无参数的）

final关键字
1，修饰的类不竜被继承
2，修饰的方法不能被重写
3，修饰的变量（成员或者局部）是常量，只能赋值一次

抽象类
抽象方法：没有方法体，用abstract修饰，不可被调用（区别于构造方法，没有方法体和方法体是空是不同概念）
抽象类：包含抽象方法（也可以没有抽象方法）使用abstarct修饰
1，抽象类不可以实例化，
2，可以通过继承重写来实现抽象类中的方法（可能是抽象方法，实现可以理解为重写）
接口
1，当一个抽象类中所有方法都是抽象的则可以被成为接口，
2，用interface来声明（声明区别于修饰，没有class，class也是一种声明）
3，接口中的变量和方法都默认用publicabstract修饰，默认publicstaticfinal修饰
4，使用implement实现接口中方法
5，接口中的方法都是抽象的，不能实例化对象
6，当一个类实现接口的时候如果该类是抽象类则实现部分即可，否则需要实现全部方法
7，一个类可以实现多个接口，用逗号隔开。
8，接口可以通过extends关键字继承多个接口（区别于类）
9，一个类在继承父类时候也可以实现接口，extends需要在implement之前。//先继承后实现
10，实现接口的方法需要在前面加上public

多态：传入的参数类型不同导致执行效果的各异现象名为多态
interface Animal{
void shout();
}
class Cat implements Animal{
public void shout(){
System.out.print(“MiaoMiao”);
}
}
class Dog implements Animal{
public void shout(){
System.out.print(“WangWang”);
}
}
public class Polymorphic {
public static void main(String [] args){
Animal cat=new Cat();
Animal dog=new Dog();
AnimalShout(cat);
AnimalShout(dog);
}
static void AnimalShout(Animal animal){
animal.shout();
}
}

对象类型的转换
1，多态中的将子类对象当作父类使用时候不需要任何显式的声明。但是不能通过父类变量去调用子类中的方法

instanceof关键字
作用：判断一个对象是否为某一个类（或者接口）的实例
语法：对象（对象引用变量）instanceof类（或者接口）
返回值：true或false

异常类
继承与java.lang.Throwable
分类：分为Error类和Exception类，主要讨论Exception

Error类：表示错误，严重的，程序无法处理

Exception表示异常，程序本身可以处理的

Throwable类常用方法

异常捕获：
1，try…catch
try{程序代码块}catch（ExceptionType（Exception类及其子类）e）{}

2，finally{}
表示无论是否发生异常还是return都要往下执行（但是在System.exit()语句执行后就不会往下执行了）

异常抛出
1，throw关键字声明抛出异常
修饰符返回值类型方法名（参数1，参数2）throwExceptionType

Exception异常分类：分为运行异常和编译异常
编译异常
除了RuntimrException类及其子类之外其他都是编译异常
java编译机会对其检查，不处理无法通过
处理方法：
1，使用try…catch语句对异常捕获
2，使用throw关键字生命抛出异常，调用者对其处理

运行异常
RuntimeException类及其子类
其实没有异常捕获或者抛出程序能编译通过，一般有逻辑错误引起，比如数组访问时超过最大角标。

自定义异常
1，使用super语句调用Exception异常
2，throwException异常对象

class DivideByMinusException extends Exception{
public DivideByMinusException(){
super();//调用无参的的构造函数
}
public DivideByMinusException(String message){
super(message);
}
}

线程的创建
方式一：继承java.lang包下的Thread类，覆写Thread类的run()方法，
一个类一旦继承了Thread类就无法继承其他类
package Test;
class Exception{
public static void main(String []args){
MyThread myThread=new MyThread();
myThread.start();
while(true){
System.out.println(“main()方法正在执行”);
}
}
}
class MyThread extends Thread{
public void run(){
while(true){
System.out.println(“MyThread类正在执行”);
}
}
}

方式二：通过传递一个实现java.lang包下的Runnable接口的实例对象给Thread的一个构造方法Thread（Runnabletarget），Runnable是一个接口只有一个方法run()；
package Test;
class Exception{
public static void main(String []args){
MyThread myThread=new MyThread();
Thread thread=new Thread(myThread);
thread.start();
while (true) {
System.out.println(“main方法正在运行”);
}
}
}
class MyThread implements Runnable{
public void run(){
while (true){
System.out.println(“MyThread方法正在运行”);
}
}
}

两种方式实现多线程的对比
1，第二种比较有优势，特别是在多个线程共享一个资源的时候可以防止错误，：
package Test;

class Exception{
public static void main(String []args){
MyThread mt=new MyThread();
new Thread(mt,”window1”).start();
new Thread(mt,”window2”).start();
new Thread(mt,”window3”).start();
new Thread(mt,”window4”).start();
}
}
class MyThread implements Runnable{
private int tickets=1000;
public void run(){
while(!(tickets==0)){
if (tickets>0){
Thread thread=Thread.currentThread();
String thread_name= thread.getName();
System.out.println(thread_name+”正在发售第”+tickets—+”张票”);
}
}
}
}

Thread常见的方法：

后台程序
1，对java而言，只要有一个前台线程还在运行，这个进程就不会停止。如果一个进程只有后台线程运行，则进程会停止
2，一个线程启动start(）方法之前调用了is.Daemon()；方法的话，当前台线程停止后，后台进程也会接着停止（后台响应需要时间）

线程的生命周期及其转换

线程的调度
两种模式：分时调度、抢占式调度，java虚拟机默认是分时调度

线程优先级：
优先级越高CPU执行的机会越大
Thread类的优先级常量

设置优先级方法：public final void setPriority(int newPriority)，接受1-10的优先级
或者以上常量，设置优先级时候一般放在stat()之前

线程休眠
方法：public static void sleep(long millis)throws InterruptedException
1，可以传入整数的表示休眠的豪秒数
2，sleep ()静态方法，智能控制当前的线程，不能控制其他线程
3，需要抛出异常，抛出InterruptedException，eg：
public static void main(String[]args) throws Exception {
if (i==3){
try {
Thread.sleep(3000);
}catch (Exception e){
e.printStackTrace();
}
}
}

线程让步
方法：public static void yield()，
1，与sleep（）一样都可以让线程暂停，但是yield()，不会阻塞线程，而是让系统重新调度线程。只有比当前线程优先级更高或者相同的线程才能获得执行机会

线程插队
方法：public final void join()
1，当多个线程正在运行的时候，某一调用该方法则会被优先执行

同步代码块
为了线程安全，在处理共享资源保证某个资源在任何时刻只能有一个线程访问
关键字：synchronized
语法：
sychronized(lock){}
1，lock为一个说对象，默认是1，1时能被执行，0时表示阻塞
2，为了保证现成的持续执行，会将同步代码块放入死循环中，只有当满足某个条件时用break跳出死循环
3，lock可以是任意对象，但必须是唯一的，任意指的是类型。
一般在同步代码块之前添加：Object lock=newObject()；来定义共享的锁对象

同步方法
与同步代码块的原理一样，只是加诸于方法上
格式：
synchronized返回值类型方法名（参数1，..）
1，同步方法的锁对象是当前调用该方法的锁对象。可以保被配共享且唯一
2，静态方法的锁对象是方法所在类的class对象，可以用类名.class方式获取。
3，同步的方式解决了线程安全问题，但是效率低

包装类
装箱与拆箱：
基本数据类型转引用数据类型为装箱
引用数据类型转为基本数据类型拆箱、

集合
概述：位于java.util包中，主要有Collection接口和Map接口，长度可变、可以存储任意类型
Collection：单列集合，包含List和Set两个子接口
List包含的实现类：（有序可重复）
ArrayList：查找快增删慢
LinkedList：查找慢增删快
Vector
Set包含实现类：（不可重复）
HashSet：无序
TreeSet：有序
Map：双列集合
每个元素有含有一个键key和一个值value，是映射关系
HashSet，HashMap，TreeMap

集合索引和数组一样是从0开始，如果访问超出范围会显示：
IndexOutOfBoundsException角标越界错误

Collection接口
通用方法：

List接口：
通用方法

ListedList中特有的方法

Iterator接口
用于遍历集合，Collection的iterator()获取迭代对象
import java.util.ArrayList;
import java.util.Iterator;
class test3 {
public static void main(String[]args){
ArrayList list=new ArrayList();
list.add(“data_1”);
list.add(“data_2”);
list.add(“data_3”);
list.add(“data_4”);
Iterator it=list.iterator();
while(it.hasNext()){
Object obj=it.next();
System.out.println(obj);
}
}
}
涉及的方法：
E next()，返回一个元素
boolean hasNext()，判断是否还有是最后一个元素
Iterator接口中的方法

foreach循环
作用：用于遍历集合循环
格式：
for（容器中的元素类型临时变量：容器变量）
执行语句
1，foreach循环并不能修改数组中元素的值
2，在使用Iterator迭代器对集合进行迭代时，如果调用了remove()方法对集合进行了删除元素，迭代器迭代预期发生改变导致迭代结果不准确，会导致并发修改异常ConcurrentModificationException，为了避免出现此异常，
package Test;
import java.util.ArrayList;
import java.util.Iterator;
public class Test2 {
public static void main(String[]args){
ArrayList list=new ArrayList();
list.add(“jack”);
list.add(“rose”);
list.add(“Tom”);
list.add(“Annie”);
Iterator it=list.iterator();
while(it.hasNext()){
Object obj=it.next();
if(“Annie”.equals(obj))
list.remove(obj);
}
}
}
解决方法一：只需找出该元素删除后使用break跳出循环
if(“Annie”.equals(obj)){
list.remove(obj);
break;
}
解决方法二：使用迭代器的删除方法（还是会迭代完整个集合）
if(“Annie”.equals(obj)){
it.remove()//则Annie不会被迭代出来
}
Set接口
HashSet类：无序不可重复，根据对象的哈希值存入相应的位置，易查找和存储
1，一下情况会自动排除重复项目
public class Test {
public static void main(String[]args){
HashSet hs=new HashSet();
Student st1=new Student(“1”,”Jack”);
Student st2=new Student(“2”,”Rose”);
Student st3=new Student(“2”,”Rose”);
hs.add(“1”);
hs.add(“2”);
hs.add(“2”);
System.out.println(hs);
}
}

以下则不会
package Test;

import java.util.HashSet;
import java.util.Iterator;

public class Test {
public static void main(String[]args){
HashSet hs=new HashSet();
Student st1=new Student(“1”,”Jack”);
Student st2=new Student(“2”,”Rose”);
Student st3=new Student(“2”,”Rose”);
hs.add(st1);
hs.add(st2);
hs.add(st3);
System.out.println(hs);
}
}
class Student{
String id;
String name;
public Student(String id,String name){
this.id=id;
this.name=name;
}
public String toString(){
return id+”:”+name;
}
}
需要重写equals()和hashCode();
package Test;
import java.util.HashSet;
import java.util.Iterator;
public class Test {
public static void main(String[]args){
HashSet hs=new HashSet();
Student st1=new Student(“1”,”Jack”);
Student st2=new Student(“2”,”Rose”);
Student st3=new Student(“2”,”Rose”);
hs.add(st1);
hs.add(st2);
hs.add(st3);
System.out.println(hs);
}
}
class Student{
private String id;
private String name;
public Student(String id,String name){
this.id=id;
this.name=name;
}
public int hashCode(){
return id.hashCode(); //返回id的哈希值（原本默认）
}
public boolean equals(Object obj){ //重写equals()方法
if(this==obj){ //判断是否是同一个对象
return true; //如果是直接返回true
}
if(!(obj instanceof Student)){ //判断对象是否为Student类型
return false;
}
Student stu=(Student) obj;
boolean b=this.id.equals(stu.id);//判断ID值是否相同
//或者boolea b=this.id==stu.id;
return b;
}
public String toString(){
return id+”:”+name;
}
}

TreeSet集合
采用自平衡的排序二叉树来存储元素，保证没有重复的元素且可以排序，

Map接口
描述：一种双列接口，每个元素包含一个Key键对象和一个Value对象，键和值之间存在的对应关系称为映射，只要指定了Key就能找到value，Key有唯一性不可重复。键相同值覆盖，

常用方法

HashMap集合
Map的一个实现类，

遍历方法一：
先遍历键，由键取出值
public class Test {
public static void main(String[]args){
Map map =new HashMap();
map.put(“1”,”jack”);
map.put(“2”,”Rose”);
map.put(“3”,”Lucy”);
Set keySet=map.keySet(); //获取键的集合
Iterator it=keySet.iterator(); //迭代键的集合
while(it.hasNext()){
Object key=it.next();
Object value=map.get(key); //获取每个键对应的值
System.out.println(key+”:”+value);
}
}
}