课程总结

1、java简介

 

（1）java历史

 

（2）重要概念

javaSE（标准版）  javaEE（企业版） javaME（微型版）
JDK（java开发工具包）JRE（java运行环境）IDE（集成开发环境）
- Java SE（Java Platform，Standard Edition）。Java SE 以前称为 J2SE。它允许开发和部署在桌面、服务器、嵌入式环境和实时环境中使用的 Java 应用程序。Java SE 包含了支持 Java Web 服务开发的类，并为 Java Platform，Enterprise Edition（Java EE）提供基础。  J2SE就是做那种桌面安装程序样的，像QQ，WORD那种应用程序。
-  Java EE（Java Platform，Enterprise Edition）。这个版本以前称为 J2EE。企业版本帮助开发和部署可移植、健壮、可伸缩且安全的服务器端 Java 应用程序。Java EE 是在 Java SE 的基础上构建的，它提供 Web 服务、组件模型、管理和通信 API，可以用来实现企业级的面向服务体系结构（service-oriented architecture，SOA）和 Web 2.0 应用程序。 J2EE 就是做基于Internet的应用程序，像选课系统，企业网站，银行系统之类的。
-  Java ME（Java Platform，Micro Edition）。这个版本以前称为 J2ME。Java ME 为在移动设备和嵌入式设备（比如手机、PDA、电视机顶盒和打印机）上运行的应用程序提供一个健壮且灵活的环境。Java ME 包括灵活的用户界面、健壮的安全模型、许多内置的网络协议以及对可以动态下载的连网和离线应用程序的丰富支持。基于 Java ME 规范的应用程序只需编写一次，就可以用于许多设备，而且可以利用每个设备的本机功能。 J2ME就是做嵌入式系统开发的，像手机游戏之类的，像现在流行的Android操作系统。
- JDK（Java Development Kit）。
- JRE（Java Runtime Environment）
- IDE（Ind Depvelopment Environment）

 

2、环境搭建

JDK、Eclipse

 

(1)下载

 

(2)安装

 

(3)配置

 

3、数据类型

 

(1)基本数据类型

 

(2)对象/引用数据类型

String 和 自定义类 接口 抽象类
     String、StringBuffer和StringBuilder三者的区别：1.String是常量，StringBuffer和StringBuilder是变量，修改时不生成新的对象，内存使用上占优势；2.StringBuffer是线程安全的，StringBuilder非线程安全；3.执行速度：（StringBuilder，StringBuffer）>String；
综上所诉：1.当数据量不是很大的时候用String；2.单线程用StringBuilder；3.多线程用StringBuffer 三者区别详解

 

4、命名规范

只有确保了命名的唯一性和描述性，才能保证资源之间不相互冲突并且便于理解记忆。
① 标识符的组成：字母，数字，下划线，$，不能以数字开头，不能使用关键字和保留关键字。ps：关键字是指java中已经定义的具有特定功能的标识符，不能用作普通标识符
 
② 包的命名
Java包的名字都是由小写单词组成。每一名Java程序员都可以编写属于自己的Java包，为了保障每个Java包命名的惟一性，最新的Java编程规范要求程序员在自己定义的包的名称之前加上惟一的前缀。由于互联网上的域名是不会重复的，所以程序员一般采用自己在互联网上的域名作为自己程序包的惟一前缀。
例如：net.frontfree.javagroup。
③ 类的命名
类的名字必须由大写字母开头，一个单词中的其他字母均为小写。如果类名称由多个单词组成，则建议将每个单词的首字母均用大写，例如TestPage。如果类名称中包含单词缩写，则建议将这个词的每个字母均用大写，如：XMLExample。由于类是设计用来代表对象的，所以建议在命名类时应尽量选择名词。
④ 方法的命名
方法的名字的第1个单词应以小写字母开头，后面的单词则建议用大写字母开头(驼峰原则)。
例如：sendMessge()。
⑤ 常量的命名
常量的名字应该都使用大写字母，并且指出该常量完整含义。如果一个常量名称由多个单词组成，则建议用下划线来分割这些单词。
例如：MAX_VALUE。
⑥ 参数的命名（驼峰原则）
参数的命名规范和方法的命名规范相同，而且为了避免阅读程序时造成迷惑，请在尽量保证在参数名称为一个单词的情况下，参数的命名尽可能明确。**注意：**1、类的属性允许不进行初始化；2、方法内部的变量要进行初始化
⑦ javaDoc注释
Javadoc注释是一种多行注释，以/*开头，而以/结束，注释可以包含一些HTML标记符和专门的关键词。使用Javadoc注释的好处是编写的注释可以被自动转化为在线文档，省去了单独编写程序文档的麻烦。例如：

 

    /**
*This is an example of
* Javadoc
*
*@author darchon
*@version 0.1, 10/11/2002
*/
//单行注释
块注释
/*注释快*/12345678910

在每个程序的最开始部分，一般都用Javadoc注释进行程序的总体描述以及版权信息。在主程序中可以为每个类、接口、方法、变量添加Javadoc注释，每个注释的开头部分先用一句话概括该类、接口、方法、变量所完成的功能，这句话应单独占据一行以突出其概括作用，在这句话后面可以跟随更加详细的描述段落。
在描述性段落之后还可以跟随一些以Javadoc注释标签开头的特殊段落，例如上面例子中的@auther和@version，这些段落将在生成的文档中以特定方式显示。
虽然添加注释不会使一个设计低劣的程序变成好的程序，但是如果按照编程规范编写程序，并且为程序添加良好的注释，却可以帮助编写出设计优美、运行高效且易于理解的程序，尤其在多人合作完成同一项目时，编程规范非常重要。俗话说”磨刀不误砍柴工”，花费一点时间去适应一下Java编程规范是有好处的。

 

5、流程控制

分支语句（条件语句）
循环语句（）

 

6、类和对象

 

（1）辨析成员变量、局部变量和全局变量

成员变量：在类体的变量部分中定义的变量，也称为属性。
局部变量：是指在程序中，定义在特定的方法或语句块的变量，是相对与全局变量而言的。
成员遍历和局部变量的区别

 

public class Test{
　　int a=0; //全局变量
　　public static void main(String[] args){
　　int b =0；//局部变量
    }
}123456

1.定义的位置不同：成员变量直接定义在类内部，局部变量是定义某个方法体内部；2.作用域不同：成员变量适用于整个类和与该类相关的类，局部变量只适用于该方法内部；3初始值不同：成员变量可以不显式初始化它们可以由系统设定默认值，局部变量没有默认值，所以必须设定初始赋值；4.不同方法可以有重名的局部变量；5.如果类变量和局部变量重名，局部变量更有优先级；

成员变量又可以细分为：实例变量、类变量（静态变量）

 

public class Clothes
{
String id; //实例变量
private String colorType; //实例变量
private int size; //实例变量
private static String depart; //类变量
final String design="yangzi"; //常量
}12345678

实例变量和类变量的区别
 1.实例变量：不用static修饰，它只能通过对象调用而且所有对象的同一个实例变量是共享不同的内存空间的；
 2.类变量：又叫静态变量，用static修饰，它可以直接用类名调用也可以用对象调用，而且所有对象的同一个类变量都是共享同一块内存空间的；

 

（4）Java的构造方法

 1.程序运行的时候构造方法就被加载；2.每个类都有构造方法，如果程序员给类提供构造方法，编译器会自动创建一个默认的构造方法；
 3.构造方法重载类似于方法的重载，一个类可以有多个构造方法，但参数列表必不同。
12

 

（5）static（静态变量、静态方法和静态初始化块）

含义：“static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问。Java中static方法不能被覆盖， 因为方法覆盖是基于运行时动态绑定的，而static方法是编译时静态绑定的。static方法跟类的任何实例都不相关，所以概念上不适用。
      是静态修饰符，什么叫静态修饰符呢？大家都知道，在程序中任何变量或者代码都是在编译时由系统自动分配内存来存储的，而所谓静态就是指在编译后所分配的内存会一直存在，直到程序退出内存才会释放这个空间，也就是只要程序在运行，那么这块内存就会一直存在。这样做有什么意义呢？ 
在Java程序里面，所有的东西都是对象，而对象的抽象就是类，对于一个类而言，如果要使用他的成员，那么普通情况下必须先实例化对象后，通过对象的引用才能够访问这些成员，但是有种情况例外，就是该成员是用static声明的（在这里所讲排除了类的访问控制）
静态变量和静态方法：
     1.静态变量可以直接被类和对象调用；2.静态方法中不能直接调用非静态变量和非静态方法，可以通过创建对象调用；3.普通方法中可以直接调用 类中的静态和非静态变量；
实例：

 

public class HelloWorld {
    static String s = "你好，静态变量！";// 静态变量
    String s1 = "你好，我是非静态变量！";

    public static void say() {
        System.out.println("你好，我是静态方法，我被调用了");
        // System.out.println(s1); 这句编译器会报错，因为静态方法中不能调用非静态变量
        // 如果想在静态方法中调用非静态变量，可以创建类的对象，通过该对象调用非静态变量
        HelloWorld hw = new HelloWorld();
        System.out.println("我是通过在静态方法中实例化类，通过类调用静态变量：" + hw.s1);

        // 静态方法中不能直接调用非静态方法，需要创建对象来调用
        // shuo(); 编译器会报错
        hw.shuo();
    }

    public void shuo() {
        System.out.println("你好，我是普通方法，我被调用了");
        System.out.println(s);
        System.out.println(s1);
    }

    public static void main(String[] args) {
        // 类直接调用静态变量
        System.out.println(HelloWorld.s);
        // 对象调用静态变量
        HelloWorld hw = new HelloWorld();
        System.out.println(hw.s);

        // 类直接调用静态方法
        HelloWorld.say();
        // 对象调用静态方法
        hw.say();

        // shuo();静态方法中不能直接调用非静态方法

    }
}1234567891011121314151617181920212223242526272829303132333435363738

静态初始化块：
    静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。
    实例：

 

public class HelloWorld {
    static int num1;
    int num2;
    int num3;

    static {
        num1 = 1;
        System.out.println("通过静态初始化块赋值");
    }
    {
        num2 = 2;
        System.out.println("通过初始化块赋值");
    }
 public HelloWorld(){
     num3 = 3;
     System.out.println("通过构造方法赋值");
 }

    public static void main(String[] args) {
        HelloWorld hw = new HelloWorld();//实例化类
        System.out.println("num1:"+ num1);
        System.out.println("num2:"+ hw.num2);
        System.out.println("num3:"+ hw.num3);
        HelloWorld hw2 = new HelloWorld();//再次实例化
    }
}123456789101112131415161718192021222324252627

实例总结：1.执行顺序上，先执行静态代码块，再执行普通代码块，最后执行构造方法。2.注意：静态代码块只在类加载时执行一次，所以在再次创建对象是静态初始化块并未再次执行。3.静态初始化块只能给静态变量赋值，不能初始化普通的成员变量；

 

（8）按值传递和引用传递

参数按值传递，传递的是值的拷贝，也就是说传递后就互不相关了，不会影响原值。
参数按引用传递，传递的是值的引用，也就是说传递前和传递后都指向同一个引用（也就是同一个内存空间），因此，外部对引用对象所做的改变会反映到所有的对象上。
按值传递和引用传递详解

 

（9）Object类（是java所有类的超类）

Object()
默认构造方法
clone()
创建并返回此对象的一个副本。
equals(Object obj)
指示某个其他对象是否与此对象“相等”。
finalize()
当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
getClass()
返回一个对象的运行时类。
hashCode()
返回该对象的哈希码值。
notify()
唤醒在此对象监视器上等待的单个线程。
notifyAll()
唤醒在此对象监视器上等待的所有线程。
toString()
返回该对象的字符串表示。
wait()
导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。
wait(long timeout)
导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量。
wait(long timeout, int nanos)
导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量。

（10）UML

 

二、java进阶

 

1、Java面向对象编程（OOP）

面向对象的编程优点：代码开发模块化，易于维护和理解，代码复用性，增强代码的可维护性和灵活性，
- 封装：将对象封装成类，类隐藏内部的实现细节，统一提供属性和方法，便于代码的维护。
                 java中的访问修饰符: 1.private：只有本类内部可以访问，且不能被访问（继承）；2.默认（不加访问修饰符），只能在本类和同一包中使用   3.protected：能在本类，同一包（package）下，和该类的子类被访问（该子类可以不和父类在一个包下）；4.public：公开的，都可以被访问（继承）内部类：??????
- 继承：继承是类与类之间的一种关系，子类可以使用父类的属性和方法(父类的属性和方法不能是privata)，增加了代码的复用性，也为多态的实现提供了前提。
              注意：1.java中只能实现单继承；2.super（）代表在子类中调用父类的构造方法；3.this.属性/this.方法，表示访问本类中的属性和方法，this（）代表调用本类的构造方法；3. 类与类之间的关系：继承关系；依赖关系（该类对象作为另 一个类中一个方法的参数）实现关系（实现是类与接口之间最常见的关系）类与类之间的关系详解4.final关键字：可以修饰类、方法、属性和变量，
              修饰类该类不能被继承，修饰方法该方法不能被覆盖，修饰属性该属性不能自动初始化，修饰变量该变量只能赋一次值
              5.java中继承的执行顺序：父类属性初始化–>父类构造方法–>子类属性初始化–>子类构造方法

 

class A {
    static {
        System.out.println("父类静态初始化块赋值");
    }
    {
        System.out.println("父类初始化块赋值");
    }
 public A(){
     System.out.println("父类构造方法赋值");
 }
}

class B extends A{
    static {
        System.out.println("子类静态初始化块");
    }
    {
        System.out.println("子类初始化块");
    }
 public B(){
     System.out.println("子类构造方法");
 }
}
public class Test {
    public static void main(String[] args) {

        B b1 = new B();//实例化类
        System.out.println();
        B b2 = new B();//再次实例化
    }
}12345678910111213141516171819202122232425262728293031

执行结果：（即为顺序）
父类静态初始化块赋值
子类静态初始化块
父类初始化块赋值
父类构造方法赋值
子类初始化块
子类构造方法

父类初始化块赋值
父类构造方法赋值
子类初始化块
子类构造方法

多态：重用、重载、动态调用构成了多态。体现：子类生产父类对象
       Animal  A = new Cat();

 

class Father{
    public void fun1(){
        System.out.println("父类的fun1()");
    }
    public void fun2(){
        System.out.println("父类的fun2()");
    }

}
class Son extends Father{
        public void fun1(){
        System.out.println("子类的fun1()");
    }

    public void fun2(int i){
        System.out.println("子类的fun2(int i)");
    }
}
public class duotai {
    public static void main(String[] args) {

        Father f = new Father();
        f.fun1();
        f.fun2();
        System.out.println();

        Son s = new Son();
        s.fun1();
        s.fun2(1);
        s.fun2();
        System.out.println();

        Father f1 = new Son();
        f1.fun1();//父类的fun1（）被重写/覆盖，所以调用的是子类的fun1（）
        f1.fun2();//父类中没有定义fun2(int i)所以不能被调用
    }

}

以上实例说明：1.子类生成父类对象，子类重写/覆盖（返回值类型、方法名和参数都相同但方法的内部实现不同）父类的方法,调用时直接调用子类的方法；2.子类重载（返回值和方法名相同，参数不同）父类的方法，根据参数值调用子类方法；3.子类生产父类对象，调用的方法父类中必须要有相应的实现，在子类中被重写。
 关于多态的一个经典实例：

 

class A {
    public String show(D obj){
           return ("A and D");
    }
    public String show(A obj){
           return ("A and A");
    }
}
class B extends A{
    public String show(B obj){
           return ("B and B");
    }
    public String show(A obj){
           return ("B and A");
    }
}
class C extends B{}
class D extends B{}
public class jingdianduotai {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();
        System.out.println(a1.show(d));//A and D
        System.out.println(a1.show(b));//A and A
        System.out.println(a1.show(c));//A and A
        System.out.println();
        System.out.println(a2.show(d));//A and D
        System.out.println(a2.show(a1));//B and A，子类重写了父类的方法
        System.out.println(a2.show(b));//B and A
        System.out.println(a2.show(c));//B and A
        System.out.println();
        System.out.println(b.show(b));//B and B 

        /*
         * 1.先在类B中招找方法show(c)
         * 2.没有
         * 3.再找b.show（super（c））即b.show(b)
         * 4.所以为B and B
         */
        System.out.println(b.show(c));
        System.out.println(b.show(d));//A and D,子类继承了父类的方法
    }

}1234567891011121314151617181920212223242526272829303132333435363738394041424344454647

引用类型转换：1.向上类型转换（隐式/自动类型转换），小类型到大类型转换（无风险）Animal animal = new Dog();；2.向下类型转换（强制类型转换），大类型到小  类型（存在方向）Animal animal = new Dog()；Dog dog = (Dog)animal;与Dog dog = new (Dog)Animal（）；不同，后者不能进行类型转换。用 instanceof关键字验证（animal instanceof Cat）是否能进行类型装换。

 

class Dog extends Animal{
    public void eat(){
        System.out.println("狗吃骨头");
    }
    public Dog(){
        System.out.println("Dog执行了！！");
    }
}
class Cat extends Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public Cat(){
        System.out.println("Cat执行了！！");
    }
}
public class TestInstanceOf {

    public static void main(String[] args) {
        Animal animal = new Dog();
        if(animal instanceof Dog){
            Dog dogn = (Dog)animal;
        }else{
            System.out.println("Dog-->animal无法进行类型转换！");
        }

        if(animal instanceof Cat){
            Cat cat = (Cat)animal;
        }else{
            System.out.println("Cat-->animal无法进行类型转换！");
        }
    }

}12345678910111213141516171819202122232425262728293031323334

多态总结： 方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

 

2、抽象类和接口

抽象类（抽象类是约束子类必须拥有哪些方法，并不关注子类的实现）：
实例：

 

abstract class A{
    public abstract void doSomthing();//定义抽象方法修饰符必须是public（缺省值）或protected
    public  void fun(){//抽象类中的非抽象方法
        System.out.println("Im A.run(),Helllo");
    }
}
class B extends A{
    public void doSomthing() {//子类必须实现父类的抽象方法
        System.out.println("Im B,doSomthing!");
    }
    public  void fun(){
        System.out.println("Im B.run(),Hello!");
    }
}

class C extends A{
    public void doSomthing() {
        System.out.println("Im C,doSomthing!");
    }
}

public class Test{
    public static void main(String[] args) {
        A a1 = new B();
        A a2 = new C();
        B b = new B();
        C c = new C();
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(b);
        System.out.println(c);
        a1.fun();
    }
}

抽象类总结：1.包含抽象方法的类一定抽象类，定义了抽象类（abstract class A）不一定有抽象方法，抽象类中也可以定义普通方法；
2.抽象类必须用public或protected修饰；
3.抽象类不能用来创建对象；
4.如果一个类继承了抽象类则子类必须实现父类的所有抽象方法方法。

接口（接口泛指供别人调用的方法或者函数）：
实例

 

interface A{
    String s="sd";//接口中变量被隐式的指定为 publin static final
    public void doSomething();//接口中所有方法被隐式的指定为public abstract(抽象方法)，所以说接口中只有抽象方法
}
interface B{
    public void playSomething();
}
class C implements A,B{
    public void doSomething(){//实现类必须实现接口所有的方法

    }
    public void playSomething() {

    }
}

接口总结：1.接口中的方法都是抽象方法；2.一个类可以实现多个接口，一个非抽象的类实现了某个接口就必须实现接口中的所有方法（换
                    句话说:对于遵循某个接口的抽象类，可以不实现该接口中的抽象方法）；

抽象类和接口的区别：
以下实例实现了一个会报警门，门的开关是门这一类事物特有的属性，但报警并不是（所有的门并不一定都是会报警的门），报警仅仅可以说是一种行为，一种门可能会有也可能不会有的行为，所以用接口去定义这种行为，你的门有报警功能就去实现（implements）这个接口呗，反之这不去实现。
实例

 

    }
}

区别总结：1.抽象类里可以有非抽象方法,而接口内的方法都是抽象的（public abstract）；2.抽象类多用来对一类事物共有属性的抽象，接
                  口只是提供对扩展行为的；3.接口里定义的属性都是final的，接口定义的方法只能是public ；4，一个类可以实现多个接口但只
                  能继承一个抽象类； 
 抽象类和接口详解

 

3、包和修饰符

 

4、常用类

 

（1）String类

 

（2）包装类

基本数据类型对应的包装类：byte char          boolean short    int         long    float    double
                                               Byte Character     Boolean Short    Integer     Long    Float    Double
目的：把基本数据类型转化成对象类型，java是面向对象的语言，对象类型可以承载更多的信息和操作，另外包装类都实现类Compareable接口可以实现对象之间的比较。
举例：

 

Integer i = 100;//自动装箱
int t = i;//拆箱，实际进行的操作是 t=i.intValue();

//在运算的时候，也可以进行自动拆箱
Integer i = 100;
System.out.println(i++);123456

equals() 比较的是两个对象的值（内容）是否相同。
“==” 比较的是两个对象的引用（内存地址）是否相同，也用来比较两个基本数据类型的变量值是否相等。
 自动拆装箱详解

 

（3）Date类

 

（4）Math类

 

5、集合框架

java集合类
java集合类中基本的接口：
Collection：是集合类的上级接口,继承与他的接口主要有Set 和List.
List：以特定次序来持有元素，可有重复元素；
Set:无法拥有重复元素,内部排序（无序）；
Map:键值对key–value，value可多值
集合类特性(几个常用类的区别)
 
集合类特性(几个常用类的区别)：
ArrayList: 元素单个，效率高，多用于查询  Vector: 元素单个，线程安全，多用于查询  LinkedList: 元素单个，多用于插入和删除  HashMap: 元素成对，元素可为空  HashTable: 元素成对，线程安全，元素不可为空
WeakHashMap: 是一种改进的HashMap，它对key实行“弱引用”，如果一个key不再被外部所引用，那么该key可以被GC回收
Iterator与ListIterator有什么区别
1. Iterator可用来遍历Set和List集合，但是ListIterator只能用来遍历List。  
2. Iterator只能正向遍历集合，适用于获取移除元素。ListIerator继承Iterator,可以双向列表的遍历，同样支持元素的修改。比如：增加元素，替换元素，获取前一个和后一个元素的索引，等等。
 Collection 和 Collections的区别
Collection是集合类的上级接口,继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类,他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作
ArrayList和Vector的区别
ArrayList与Vector主要从二方面来说.
一.同步性:
   Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的。
二.操作:
    由于Vector支持多线程操作，所以在性能上就比不上ArrayList了。
三.数据增长:
       ArrayList和Vector都有一个初始的容量大小，当存储进去它们里面的元素个数超出容量的时候，就需要增加ArrayList和Vector的存储空间，每次增加存储空间的时候不是只增加一个存储单元，是增加多个存储单元。
       Vector默认增加原来的一倍，ArrayList默认增加原来的0.5倍。
       Vector可以由我们自己来设置增长的大小，ArrayList没有提供相关的方法。

 

6、异常处理

 

5、IO编程

 

 

 

6、java多线程

基本概念：
进程是程序（任务）的执行过程，说明1.进程是动态的2.它持有资源（内存。。。）和线程
线程是进程的一个执行序列，是系统中最小的执行单元，一个进程可以有多个线程，线程共享进程的资源。
互斥和同步
创建线程的三种方式和常用方法：
①继承Thread类

 

 

②.实现Runnable接口

 

③.应用程序可以使用Executor框架来创建线程池
比较：Runnable方式可以避免Thread方式由于Java单继承特性带来的缺陷；Runnable的代码可以被多个进程（Thread实例）共享，适合于对个线程处理同一资源的情况

线程在执行过程中，可以处于下面几种状态：
就绪(Runnable):线程准备运行，不一定立马就能开始执行。
过一个公有的静态的方法获取该对象。 ：

                                                                                                这个学期我的熟悉觉得重要的一些知识点如下

1. 对象的初始化

   　　(1) 非静态对象的初始化

   　　在创建对象时，对象所在类的所有数据成员会首先进行初始化。

   　　基本类型：int型，初始化为0。

   　　如果为对象：这些对象会按顺序初始化。

   　　※在所有类成员初始化完成之后，才调用本类的构造方法创建对象。

   　　构造方法的作用就是初始化。

   　　(2) 静态对象的初始化

   　　程序中主类的静态变量会在main方法执行前初始化。

   　　不仅第一次创建对象时，类中的所有静态变量都初始化，并且第一次访问某类(注意此时

   　　未创建此类对象)的静态对象时，所有的静态变量也要按它们在类中的顺序初始化。2

2. 　　继承时，对象的初始化过程

   　　(1) 主类的超类由高到低按顺序初始化静态成员，无论静态成员是否为private。

   　　(2) 主类静态成员的初始化。

   　　(3) 主类的超类由高到低进行默认构造方法的调用。注意，在调用每一个超类的默认构造

   　　方法前，先进行对此超类进行非静态对象的初始化。

   　　(4) 主类非静态成员的初始化。

   　　(5) 调用主类的构造方法。3

3. 　　关于构造方法

   　　(1) 类可以没有构造方法，但如果有多个构造方法，就应该要有默认的构造方法，否则在继承此类时，需要在子类中显式调用父类的某一个非默认的构造方法了。

   　　(2) 在一个构造方法中，只能调用一次其他的构造方法，并且调用构造方法的语句必须是

   　　第一条语句。4

4. 　　有关public、private和protected

   　　(1) 无public修饰的类，可以被其他类访问的条件是：a.两个类在同一文件中，b.两个类

   　　在同一文件夹中，c.两个类在同一软件包中。

   　　(2) protected：继承类和同一软件包的类可访问。

   　　(3) 如果构造方法为private，那么在其他类中不能创建该类的对象。5

5. 　　抽象类

   　　(1) 抽象类不能创建对象。

   　　(2) 如果一个类中一个方法为抽象方法，则这个类必须为abstract抽象类。

   　　(3) 继承抽象类的类在类中必须实现抽象类中的抽象方法。

   　　(4) 抽象类中可以有抽象方法，也可有非抽象方法。抽象方法不能为private。

   　　(5) 间接继承抽象类的类可以不给出抽象方法的定义。6

6. 　　final关键字

   　　(1) 一个对象是常量，不代表不能转变对象的成员，仍可以其成员进行操作。

   　　(2) 常量在使用前必须赋值，但除了在声明的同时初始化外，就只能在构造方法中初始化

   　　。

   　　(3) final修饰的方法不能被重置(在子类中不能出现同名方法)。

   　　(4) 如果声明一个类为final，则所有的方法均为final，无论其是否被final修饰，但数据

   　　成员可为final也可不是。7

7. 　　接口interface (用implements来实现接口)

   　　(1) 接口中的所有数据均为 static和final即静态常量。尽管可以不用这两个关键字修饰

   　　，但必须给常量赋初值。

   　　(2) 接口中的方法均为public，在实现接口类中，实现方法必须可public关键字。

   　　(3) 如果使用public来修饰接口，则接口必须与文件名相同。8

8. 　　多重继承

   　　(1) 一个类继承了一个类和接口，那么必须将类写在前面，接口写在后面，接口之间用逗

   　　号分隔。

   　　(2) 接口之间可多重继承，注意使用关键字extends。

   　　(3) 一个类虽只实现了一个接口，但不仅要实现这个接口的所有方法，还要实现这个接口

   　　继承的接口的方法，接口中的所有方法均须在类中实现。9

9. 　　接口的嵌入

   　　(1) 接口嵌入类中，可以使用private修饰。此时，接口只能在所在的类中实现，其他类不

   　　能访问。

   　　(2) 嵌入接口中的接口一定要为public。10

10. 　　类的嵌入

    　　(1) 类可以嵌入另一个类中，但不能嵌入接口中。

    　　(2) 在静态方法或其他方法中，不能直接创建内部类对象，需通过手段来取得。

    　　手段有两种：

    　　class A {

    　　class B {}

    　　B getB() {

    　　B b = new B();

    　　return b;

    　　}

    　　}

    　　static void m() {

    　　A a = new A();

    　　A.B ab = a.getB(); // 或者是 A.B ab = a.new B();

    　　}

    　　(3) 一个类继承了另一个类的内部类，因为超类是内部类，而内部类的构造方法不能自动

    　　被调用，这样就需要在子类的构造方法中明确的调用超类的构造方法。

    　　接上例：

    　　class C extends A.B {

    　　C() {

    　　new A().super(); // 这一句就实现了对内部类构造方法的调用。

    　　}

    　　}

    　　构造方法也可这样写：

    　　C(A a) {

    　　a.super();

    　　} // 使用这个构造方法创建对象，要写成C c = new C(a); a是A的对象。