CoreJavaNotes(java核心部分笔记)

第一章Java概述

 

1、 Java技术

解：JavaAPI：Java Application Programming Interface。

JDK：Java Development Kit，JDK 是整个Java的核心，包括了Java运行环境、Java工具和Java基础类库。

JRE：Java Runtime Environment，Java运行环境，运行JAVA程序所必须的环境的集合，包含JVM标准实现及Java核心类库。

JVM：JavaVirtual Machine---java虚拟机

IDE：Integrated Drive Electronics----电子集成驱动器

JavaSE：Java Standard Edition--- Java平台标准版

JavaME：Java Mico Edition--- Java微版

JavaEE：Java Enterprise Edition---java企业版

 

2、 Java语言特点

解：跨平台，解释性，面向对象，分布式，可靠安全，多线程。

 

3、 面向对象语言特点：

解：继承、多态、封装、抽象。

 

4、 基本语法：

解：Java区分大小写，语句以分号（；）结束。

注释：单行注释：//这是单行注释

  多行注释：/*这是多行注释*/

  文档注释：/**这是文档注释，可以加HTML及JavaDOC标签*/

 

5、 开发环境及常见命令

解：java：编译Java源文件。

Javac：运行类文件。

Jar：打包类文件。

Javadoc：生成Java API。

注意：绝对路径和相对路径的区别。

 

6、 第一个Java程序讲解

HelloWorld.java

public class HelloWorld{

public static void main(String[]args){

System.out.pringtln(“HelloWorld”)

}

}

解：源文件名与public类名必须一致

一个Java源文件中可以定义多个类，但只能定义一个public类。

 

7、 编码规范

解：用有意义的英文单词命名类名、方法名、变量名。

类名的首字母大写。方法名及变量名首字母小写。包名字小写。

书写注意缩进，用SourceàFormat调整。

 

第二章变量、运算符、语句

1、变量

变量的四要素：类型、变量名、初始化、作用域（有效范围）。

变量的类型确定了其能拥有的值，以及能进行的运算。

 

2、类型（8+3）

基本数据类型：byte，short，int，long，char，float，double，boolean。

引用数据类型：类、接口、数组。

基本数据类型与引用数据类型的区别：

基本数据类型：内存存放（值—栈），定义方式（平台），表示结构（简单），初始方式（赋值）。

引用数据类型：内存存放（引用[地址]—堆），定义方式（用户自定义），表示结构（复杂），初始方式（构造函数）。

Short：整数的表示，正数用源码表示，最高位为0。负数用补码表示，最高位为1。补码=源码取反+1.

 

3、变量名：语法+规范

合法的标识法：首字母必须是字母、_、$开始，后面可以是字母、_、$、数字

不能是关键字，保留字：goto。在作用域范围内必须唯一。

规范：首字母小写

 

4、初始化

基本数据类型初始化：字面常量赋值

引用类型初始化：用构造方法初始化

 

5、作用域：变量定义的位置确定了其作用域。

根据作用域，可以将变量分为4类：

成员变量：范围为整个类。

局部变量：范围为所在方法。（局部变量使用前必须初始化）

方法参数：范围为方法或语句块。

异常处理参数：范围为异常处理块。

 

6、运算符

从四个方面理解运算符：功能、参与运算的操作类型、结果类型、优先级。

分类：按参加运算的操作数个数：一元、二元、三元运算符。

按功能：算术、关系、条件、移逻辑、按位、赋值、其他。

7、运算符重点（***）

A”+”号除了可以做为算术加运算外，还可以作为字符串连接符。

eg：int i=”12”+2; 则会输出：122。

B前++和后++的区别：

Eg：int i = 10;

int j = i++; //先运算后加

int k = ++i; //先加后运算

System.out.println(i+","+j+","+k); 输出结果：i=12 ；j=10；k=12；

C&&和&的区别：

解：&&是短路运算符，&不是。

&可做位运算符。

 

8、宽化处理

数值类型宽化处理（提升），若参与运算的两个类型不同，则窄的自动转化为宽的类型。宽的数值类型须强制转换为窄的类型。

宽处理示意图：byte--->short--->int--->long

 char-àint-àlong

 byte--->short--->int--->double

 char-àint-àdouble

 float-àdouble

 

9、语句

语句是一个可执行的单元，以”；”结束。

条件语句

If-else

switch-case

循环语句

for

while

do-while

跳转语句

break,continue,return,label

异常处理

Try-catch-finally

Throw/throws

 

第三章类与对象

1、类与对象的基本概念。

对象为类的一个实例（instance）。

类是清单，抽象的。对象是具体的，实际的。

**对象的三要素：唯一标识，属性（状态），方法（行为）。

 

2、名词解释。

OOA：Object Oriented Analysis。 //面向对象分析

OOD：Object Oriented Design。 //面向对象设计

OOP：Object Oriented Programming。 //面向对象编程

UML：Unified Modeling Language。 //统一建模语言

 

3、定义类

类名用有意义的英文单词命名，首字母大写

Public(访问控制符)  class(关键字)   Dog(类名){

属性，即成员变量，表示对象的状态。

构造方法，初始化对象

方法，表示对象的行为。

}

 

4、创建对象及访问成员。

//用关键字new，创建对象。

Dog dog=new Dog();

//点运算符，访问成员变量调用方法。

String name=dog,name;

Dog.yaff();

 

5、访问控制符

访问控制符共有四个：public，package，protected，private。

public：共有的，可以被任意其他类访问。

package：包级，只能被同一包中的其他类访问。

private：私有的，只能在同一类中被访问。（数据封装：成员变量设计为私有的，即private）

protected：受保护的，只能在同一包中或其子类中访问。

类的前面只能用：public，package

成员（属性，方法）、构造方法前面可以用：public，package，protected，private。

 

6、定义类的属性（成员变量）

成员变量的位置，类体内，方法外。

实例初始化块

成员变量用构造方法初始化，若在定义处没有赋值，则会输出默认值：

int：0； double：0.0； boolean：false； 引用类型：null。

 

7、类中的方法：

签名、实现、调用、传参、重载(overload)、重写(override)

方法三要素：返回类型、方法名、参数列表。

方法传参：按值传参

方法的重载：同一类中，方法的名字相同，参数的个数或者是类型不同。

方法的重写(也称方法的覆盖)：继承关系中，子类中实例方法的签名与父类中实例方法的签名相同的方法。

 

8、 构造方法：初始化对象

**基本特点：方法名就是类名；无返回类型；

与方法有相同的访问控制符；

使用new构造方法（）；

如果没有构造方法,系统会自动生成一个默认的构造方法（无参）；

构造方法可以重载；

可以用This调用其他构造方法的参数。

 

9、 静态变量（静态方法）与实例变量(实例方法)

静态变量与实例变量的区别：

静态变量：有static，每个对象相同，内存仅一份。(可通过类调用)

实例变量：无static，每个对象不同，内存有多份。(需通过对象调用)

静态方法与实例方法的区别：

静态方法：无static，可直接使用实例变量及静态变量，可直接调用实例方法及静态方法。

实例方法：有static，可直接使用静态变量与静态方法，须通过调用对象使用实例变量与实例方法。

 

10、对象的生命周期

加载类，仅一次：

初始化静态成员变量及静态初始化块。

创建对象，每次：

执行成员变量定义处的初始化及实例初始化块。

执行构造方法。

使用对象：

调用对象上的方法实现功能。

（对象不被引用时，JVM自动回收对对象占用的内存）

 

11、对象转型(casting)

一个基类的引用类型变量可以”指向”其子类对象。

一个基类的引用不可以访问其子类对象新增加的成员(属性和方法)。

可以使用引用变量instance of来判断该引用类型变量所”指向”是否属于该类或该类的子类。

子类的对象可以当作基类的对象来使用，称作向上转型(upcasting)，反之称为向下转型(downcasting)。

 

第四章数组

1、数组的基本概念

数组是有序元素的集合。

Java数组的特点：元素类型相同，长度不变。

 

2、数组的声明、定义及初始化

//声明数组，[ ]是数组的标志。

int arr [ ]; 表示创建了一个int类型的，数组名为arr的数组。

int arr1 =new int[ 5] 表示创建了一个名为arr1的数组，arr1的长度为5（即数组中有5个元素）， 元素的默认值为0；

3、访问及遍历数组元素

for(int ：arr)

 

4、数组的数组

数组的数组即为多维数组，常见的多维数组有二维数组和三位数组。

定义一个二维数组：int [ ] [ ] arr2={{1,2,3},{4,5,6}}

 

5、数组是Java对象

数组是object类的子类

属性：length，数组长度。

具有object类的方法，如：

toString()：

equals()：

 

6、数组实用工具类

java.util.Array

如：toString方法：

equals方法：

 

 

第五章应知类

1、String、StringBuilder、StringBuffer

面试题：三者之间的区别？

1）字符串常量：”java”

2)String不变性：内容不变

3）三者区别

4）常见方法

 

2、基本数据类型封装

int 自动类型转换  Integer

 

3、Math类

工具类，静态方法

 

4、Date相关类，格式化SimpleDateFormat

日期（时点）：1970年1月1日到这个时点的毫秒数。

Date类：java.util。

 

5、其它相关类

 

 

 

 

第六章继承

1、类与对象直接爱你的两种主要关系。

Has-a：部分与整体的关系。 聚合

Is-a：是一种的关系 继承

设计、实现

 

2、Java继承

基础语法：关键字（extends）

继承的目的：代码复用+父类定义了接口，子类可以提供不同的实现。

继承的特点：Object是所有类的根类。

继承是单继承，但支持多层继承。

子类继承了父类的属性与方法，但不继承构造方法。

私有的成员不被继承

Protected：包级访问权限。（只能被同一包中类访问，另外子类可以访问父类中的protected的成员）。

 

子类的初始化：

先父类，再子类。先静态，再实例。先定义，再构造。

 

类型向上转换：

子类型--->父类型（自动）

父类型--->子类型（强制）

类之间没有继承关系，不能转换。

 

编译期类型和运行期类型。

Dog  dog=new Smalldog();

编译期类型：dog所声明的类型。确定了能调用的方法。

运行期类型：dog实际指向的对象的类型。确定了实际运行时调用的方法。

构造方法的调用：

构造方法不能被继承，子类调用父类的构造方法，访问父类的成员用关键字super。

注意：

1、子类的构造方法的第一条语句必须是super语句，用来调用父类的构造方法。

2、如果子类中的构造方法中没有使用super语句，则默认调用父类的不带参数的构造方法。super（）。

 

3、同名处理---重写（override）覆盖

在继承关系下：父类{

String  name;

void fun(){} //签名相同

}

  子类{

String name; //隐藏hiding。

Void fun(){} //静态：隐藏hiding，实例：重写。

}

方法的重写：在继承关系中，子类中实例方法的签名与父类实例方法的签名完全相同的方法，称为方法的重写。

 

注意：1、重写是基于继承的，没有继承就没有重写。

  2、方法重写的实现是在子类中对父类中继承过来的非私有方法的内容进行修改的一个动作。

  3、重写中，子类的访问控制符和父类的一致，或比父类的作用域范围大。

实现方法的重写必须满足以下所有条件：

1、 重写方法的返回类型必须与父类中被覆盖方法的返回类型相同。

2、 重写方法的参数类型、次序和方法名称必须与被覆盖方法的参数类型、次序和方法名称相同。

 

 

4、抽象：abstract

1、用abstract关键字来修饰一个类时，这个类叫做抽象类。

   用abstract修饰一个方法时，该方法称为抽象方法。

2、抽象类不能被实例化。new

3、抽象方法只需声明，而不需实现。

4、含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写。

5、抽象类中可不可以有实现的方法。

抽象类中可不可以没有抽象方法。

 

5、不变：final

1、final变量的值不能被改变。（final的成员变量，final的局部变量（形参））

2、final的方法不能够被重写。

3、final的类不能够被继承。

 

6、Object类

1、需要被子类实现的方法。

protected  Object  clone() //一种创建对象的方法

protected  void  finalize() //垃圾回收时调用的方法

2、不可重写的方法 //线程编程中使用的方法

public final Class getClass()

public final void notify()

public final void notifyAll()

public final void wait(long  timeout)

public final void wait(long  timeout,int nanos)

3、可(应)被重写的方法

public  int hashCode() //返回对象的hash码

public boolean equals(Object  obj) //判断对象是否逻辑相等

public String toString() //对象的字符串表示

Hashcodes（为十六进制），代表一个对象，通过hsahcodes可以找到对应对象。

 

第七章接口

1、接口的定义。

接口（interface）是抽象方法和常量值的定义的集合。

从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。

eg：对象间的通讯协议，定义一组方法，没有实现。 Obj.method()；

 

2、Java定义接口语法：

public/package   interface   接口名{

public   static  final(可省略) int  a=10; //静态常量

public  abstract (可省略)  void   transDate( ); //抽象方法（公开的）

}

注意：接口名命名与类名一致。静态常量名用大写。

 

3、实现接口语法：（类实现接口）

public class   类名   implements  接口名，接口名(可以实现多个接口，用逗号隔开){      }

 

多个无关的类可以实现同一接口。

一个类可以实现多个无关的接口。

与继承关系类似，接口与实现类之间存在多态性。

类实现接口时，访问控制符要与接口的访问控制符一样，或更强（作用域范围更广）。

 

4、接口特性：

1、接口可以多重实现。

2、接口中声明的属性默认为public static final的。也只能是public static final。

3、接口中只能定义抽象方法，而且这些方法默认为public的，也只能是public的。

4、接口可以多继承其它接口，并添加新的属性和抽象方法

5、抽象类与接口（面试题）

1、接口中没有实现，抽象类可以有实现的方法。

2、一个类可以实现多个接口，一个类继承一个类。

3、抽象类可以实现接口。

4、抽象类实现基本的功能。

（类--->抽象类--->实现接口）

 

 

第八章多态

1、多态的必要条件：

要有继承、要有重写、父类引用指向子类对象。

 

2、 动态绑定：

是指在执行期间（而非编译期间）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

 

一个概念：同一引用类型，使用不同的实例而执行不同的操作。（同一接口呈现不同的行为）

两个要素：用父类（抽象类、接口）用作类型+依赖于方法重写。

四种情形：变量类型，方法参数类型，方法返回类型，数组类型。

 

9、设计模式（Singleton）

Singleton（单例）：只能有一个实例

 

10、内部类

内部类：

1、 在内部类中，可以定义实例变量与方法，不能定义静态变量与方法。

2、 内部类的访问控制符可以为4个，public，private、package、protected。

3、 内部类中，可以无条件的访问到外围的成员。

4、 创建内部类对象-----à先要创建外围类的实例。

Eg：InterClassDemo   icd=new   InnerClassDemo();

InnerClassDemo.InnerClass ic=icd.new InnerClass();

 

静态嵌套类：

1、 内部类加static修饰就称为静态嵌套类。

2、 静态嵌套类中，可以定义实例变量与方法。也可以定义静态变量与方法。

3、 静态嵌套类中的实例方法，不能访问外围类的实例变量，可以访问其静态成员。可以访问自己类中的实例变量和静态变量。

 

局部内部类：

1、 局部内部类就是将内部类放在方法中。

2、 局部内部类的方法可以访问到外层方法中的常量。

 

匿名内部类：

 

 

 

Instanceof：

是Java、php的一个二元操作符（运算符），和==，，是同一类东西。由于它是由字母组成的，所以也是Java的保留关键字。它的作用是判断其左边对象是否为其右边类的实例，返回boolean类型的数据。可以用在继承中的子类的实例是否为父类的实现。相当于c#中的is操作符。

 

 

 

 

第九章异常

1、异常的概念：

Java语言中，程序运行过程中发生的一个事件，这个时间改变了程序的正常运行流程，这个事件称为异常。

 

2、 异常体系结构：

Error：错误。系统级。

运行期异常（不受检查的异常）：不强制程序员处理，是RuntimeException的子类。

编译期异常（受检查的异常）：强制程序员处理，是Exception的子类，不是RuntimeException的子类。

 

3、 错误、运行期异常

错误：

OutOfMemoryError:内存

StackOverflowError：堆栈

运行期异常：

NullPointerException:空指针

ArrayIndexOutOfBoundException:数组越界

ClassCastException:类型转换

NumberFormatException: 数字格式化

ArthmeticException：除0异常

错误与运行期异常的处理：（程序员可以不处理）

JVM处理异常：

自动获得异常（对象），

终止程序的运行

将异常信息在控制台输出

 

4、关键字throw:抛出一个异常对象

关键字throw和throws的区别；

 

5、编译期异常

Exception  IOException  FileNotFoundException

   SQLException

两种处理方式：

1）方法声明:throws

2）try-catch-finally语句

运行流程

Catch语句

Finally语句：总会运行到

几种形式：try-catch-finally  try-catch  try-finally

 

6、自定义异常

运行期异常，写一个类，继承RuntimeException

编译期异常，写一个类，继承Exception

7、继承中的异常(方法)  重写

父类中方法抛出异常，子类中的重写方法可以不抛出异常或抛出一样的异常，再者可以抛出父类中已抛出异常的子类。（不允许抛出父类中异常的父类）

 

小结:

类的定义，与方法的定义

[public|package] [abstract|final] class 类名 extends 父类  implements E1,E2,…. {

[public|package|proected|private] [abstaract|final][static]  //签名

返回类型  方法名（参数列表） throws Ex1,Ex2 {}

}

 

第十章集合

1、基本概念

数组的特点：有序+长度不变+元素类型相同（包括基本数据类型和引用数据类型）。

集合特点：1、集合中的元素只能是对象（不能是基本数据类型）。

2、集合本身是一个对象，通过对象可以管理其中的元素。

2、集合框架------接口和实现分离。

a：接口体系

b：实现类

c：算法

list与set区别：

list特点：有序+可重复

set特点：无序+不可重复。

重复：是指两对象逻辑相等，之间的内容相同，equals值相同。（重写equals方法）

 

Collection：

泛型的定义：

如果集合中对象存在多种不同类型，则类型不安全，用泛型（generic）“<>”修饰。

Eg：collection<String>  c1=new Arraylist<String>();

c1.add(“java”); true

c1.add(100);      false

 

遍历：

1、 for—each

for(String  s:c1){ //s是集合中的元素

System.out.println(s);

}

2、 迭代器， Iterator接口

方法：hasNext() //集合中是否还有未遍历的元素？

  next() //获得集合中的下一个元素。

  removed（） //

eg：Iterator<String> itar =c2.iterator();

while(iter.hasNext()){

String s=itar.next();

System.out.println(s);

}

List是有序的，所有拥有get()方法，eg:l1.get(索引)；

Set和collection用法一致。

 

4、 Map:映射 

   键(key)(名字)-值(value)对的值合

键：唯一，

5、Collections实用工具：static方法，算法

Vector HashTable  HashMap1.1  1.2

ArrayList

 

第十一章输入输出系统

1、 概述 

  Input    程序  Output

  输入设备输出设备:差异性

   抽象出数据流，

 

2、流的分类：

1、按照数据流的方向不同可以分为输入流和输出流。输入(读-获取)、输出(写-送出)）

2、按照处理数据单位不同可以分为字节流和字符流。

字节流适合读取：视频，声音，图片等二进制文件，字符流适合读取：纯文本文件。Java语言中所有的字节流都以Stream结尾。。所有的字符流都含有Readerh和Writer。

 

3、按照功能不同可以分为节点流和处理流。

节点流：为可以从一个特定的数据源（节点）读写数据。

处理流\过虑流（Filter）：是“连接”在已存在的流（节点流或处理流之上），通过对数据的处理为程序提供更为强大的读写功能。

 

3、字符输入输出流

Reader抽象类

读：

int read()               读出一个字符

int read(char[] buf)       读到buf字符数组中，

int read(char[] buf,int offset,int len)

 

close() 关

FileReader：创建对象

new FileReader(文件名（相对路径或绝对路径）)

 

 

Writer抽象类

write(int ch) 写一个字符

write(char[] buf) 字一个字符数组

weite(char[] buf,int offset,int len)：写数组中的一部分到输出流

flush()   刷新数据

close()

FileWriter   new FileWriter(“”)

new FileWriter(“文件名”,true)  写的上追加

读写方法的一般流程

1)创建输入输出流对象

2)读写操作

3)关闭流

 

BufferedReader：缓存数据，提高性能  （Filter）

读一行数据：readLine()

BufferedWriter

写字符串

newline()方法，

 

4、字节输入输出流

InputStream

FileInputStream

BufferedInputStream

OutputStream

FileOutputStream

BufferedOutputStream

new BufferedInputStream(InputStream对象)

new FileInputStream(“文件名”)

PrintStream：print方法，printf方法

System.out的类型：

System.in:类型：   InputStream = == 》 InputStreamReader

  Reader == > BufferedReader

 

 

 

 

5、对象序列化

6、File类：文件（目录）

 

          字符                       字节

输入 Reader                     InputStream             read()

FileReader                       FileInputStream

BufferedReader                    BufferedInputStream

                InputStreamReader          DataInputStream    

(可以读写基本数据类型)

ObjectInputStream

                           

输出                Writer                       OutputStream           write()

                 FileWriter                      FileOutputStream

                BufferedWriter                   BufferedOutputStream

               OutputStreamWriter                  DataOutputStream

                                                 ObjectOutputStream

Filter—设计模式

new FileOurputStream(“文件名”,true)

new BufferedInputStream(InputStream对象)

new InputStreamReader(InputStream对象)

new DataOutputStream(OutputStream对象)

 

 

 

总结：(重点16个流)

1、读取文件：

FileInputStream

available()：返回流中剩余的估计字节数

skip()：跳过字节。

FileOutputStream

FileReader

FileWriter

 

2、带有缓冲区的：

BufferInputStream

BufferOutputStream

BufferReader

BufferWriter

 

3、读取数去数据的

DateInputStream

DateOutputStream

 

4、读取对象

ObjectInputStream

ObjectOutputStream

 

5、转换流（字节流转换成字符流）

InputStreamReader

OutputStreamWriter

 

6、标准

PrintWriter

PrintStream//标准的输出流（默认输出到控制台）

 

Java语言中的流分为四大家族（InputStream，OutputStream,Reader.Writer）

 

 

 

 

第十二章线程

1、 多线程的基本概念

线程是值进程中的一个执行场景，也就是执行流程。

线程与进程的的区别：

每个进程是一个应用程序，都有独立的内存空间。

同一个进程中的线程共享其进程中的内存和资源。

（共享的内存是堆内存和方法区内存，栈内存不共享，每个线程都有自己的）

1-1什么是进程？

一个进程对应一个应用程序，例如：在windows操作系统启动word时，就表示启动了一个进程。在Java的开发环境下启动JVM，就表示启动了一个进程。现代的计算机都是支持多进程的，在同一个操作系统中，可以同时启动多个进程。

 

2-2多进程有什么作用？

单进程计算机只能做一件事情。

对于单核计算机来讲，在同一个时间点上，游戏进程和音乐进程不是同时运行的。因为计算机的CPU只能在某个时间点上做一件事。由于计算机将在“游戏进程”和“音乐进程”之间频繁的切换执行，切换速度极高，人类感觉游戏和音乐在同时进行。

多进程的作用不是提高执行速度，而是提高CPU的使用率。

进程和进程之间的内存是独立的

 

3-3什么是线程

线程是一个进程中的执行场景，一个进程可以启动多个线程。

 

4-4多线程有什么作用？

多线程不是为了提高执行速度，而是提高应用程序的使用率。

线程和线程共享“堆内存和方法内存”，栈内存是独立的，一个线程一个栈。

可以给现实世界中的人类一种错觉：感觉多个线程在同时并发执行。

 

5-5Java程序的运行原理？

Java命令会启动Java虚拟机，启动JVM。等于启动了一个应用程序，表示启动了一个进程。该进程会自动启动一个“主线程”，然后主线程去调用某个类的main方法，所以main方法运行在主线程中。在此之前的所有线程都是单线程。

 

 

2、创建线程

Thread类：Thread的一个实例就代表一个线程

静态方法:Thread.currentThread()   获得当前线程对象

             Thread.sleep(毫秒)  

实例方法:

getName()/setName()

getID()      获得线程ID

getState()

getPriority()/setPriority() 优先级

start(); 启动线程

构造方法：

Thread()               Thread(String name)

Thread(Runnable target)  Thread(Runnable target，String name)

 

Runnable:接口

创建线程的两种方法：

1）写一个类继承Thread，重写run方法

2) 写一个类，类实现Runnable接口，再创建Thread对象

 

线程的启动和创建：

Java虚拟机的主线程入口是main方法，用户可以自己创建线程，床架方式有两种：

继承Thread类，重写run方法。

实现Runnable接口（推荐使用Runnable接口）

3、线程(对象)的状态

 

 

 

4、线程的调度与优先级

1)开始时线程的优先级与创建这个线程的优先级相同

2) getPriority()/setPriority(int ) 优先级

3）调度算法

高优先级优先(preemptive)

同优先级循轮(round-robin)

 

5、线程的互斥与同步(***)  线程安全

 

 

 

 

第十三章网络编程

1、URL：统一资源定位器

 http: //blog.sina.com.cn/s/blog_49f9228d0101da8v.html?tj=tech

协议    域名（IP）

2、基于TCP：Socket的编程

IP：Internet Protocol:网际互联协议

TCP:Transmission Control Protocol传输控制协议

UDP:User Datagram Protocol 用户报文协议

 

Socket=TCP+IP+抽象

端口：

编程模型：client/Server èB/S

 

3、基于UDP的编程

DatagramSocket

DatagramPacket

 

 

 

 

第十四章反射

类对象   Class  Fileld[]

                Method[]

                   类对象

类的对象 Dog       new Dog();       Dog.class

 String      new String(“”)    String.class

 TV        new TV();        TV.class

 

类文件：

[修饰符]   Class 类名  extends 父类  implements I1,I2…. {

属性;                           Field

构造方法； Constructor

方法; Method

}

Servlet容器          Servlet                 web.xml 

Struts2               Action类      配置文件struts.xml

Spring IoC容器         类                   xxx.xml

           

属性文件：.properties

1)类路径

2)name=vlaue

 

 

 

 

第十五章JDK新特性

1、小特性

1)基本数据类型与封装类型的自动转换

2)for-each语句

3）可变参数方法

Sum(int x,int y)

4)printf方法

Printf(« 格式«，变量  )

2、枚举类型:表示静态常量

 

3、范（泛）型generic：以类型为参数

List<String>  ss                 add(int x,int y)    add(1,2)

List<E>类型：

好处：类型安全 + 不要强制类型转换 + 更广泛的程序

(String)ss.get(1)

没有使用范型的类型：raw type,List list

?:表示任意类型;

? extends Number：表示Number及其子类

? super  Number：表示Number及其父类

 

范型方法:数组  è 集合

String[] 

Number[]

Dog[]

范型类: MyStack(栈):先进后出FILO

实现：数组，大小

push(Object o)

pop()

isEmpty()

 

 

4、annotation(标注、注解)：工具使用，不影响程序的运行

@Override : 重写的方法

@Deprecated：过期方法

@SuppressWarnings：取消警告信息

用在类、方法、成员变量前

 

自定义标注

//说明：标注用在代码的什么地方？方法的前面？类的前面？

//      保留标注信息：源代码，编译，运行时（反射技术读取出标注信息）

@interface  标注名 {

//方法的声明.public + abstract

//返回类型：基本数据类型，String，Class及其数组

}

基础：类型、变量、运算符、语句、数组

面向对象：类、对象、访问控制符、继承、静态变量（方法）、构造方法、对象的生命周期

、方法的调用（传参）、重载、重写、多态、封装、接口、内部类、设计模式

常见的类:str.indexOf(“”)

异常、集合、IO、范型、标注

线程、网络、反射