JAVA学习 (15天看完)
Java概述 解释型语言（经过二次编译
）JDK初步与HelloWorld
Java语言特点：了解内存
Java程序运行机制：java虚拟机 垃圾收集机制
源程序 java编译器 字节码 类装载器 字节码校验器 解释器 操作系统平台
核心机制java虚拟机（体现分层思想）
Java虚拟机制屏蔽了底层运行平台的差别，实现一次编译随处执行
核心机制垃圾收集
它提供一种系统级线程跟踪存储空间分配情况。并在JVM的空闲时检查和搜集处理空闲空间
垃圾收集在Java程序运行过程中自动运行，程序员无法精确控制和干预
开发需要JDK 用户只需JRE
程序hello.word
public class Helloworld{
public static void main(String[] args){
System.out.println("helloworld");
}
}
HelloWorld解释与程序员设置
编译：javac Helloworld.java
执行：java Helloword
用详细信息显示文件夹
存盘后编译Ctrl+S
总结
Java Application初步
Java源文件以java为扩展名。源文件的基本组成类（class）
一个源文件最多只有一个public类，其他类个数不限。如果源文件包含一个public类，它必须按该类命名
Java应用程序的入口是main()方法。
Java语言严格区分大小写
Java方法有一条条语句构成，每语句以分号结束。
Java语言的三种注释：//
Java语言基础 1.18
标识符 –不能以数字开头 不能有空格 "见名知意"
关键字 void没有返回值
Java常量
字符常量' ' 字符串" "
Java变量
从本质上讲，变量其实是内存中的一小块区域，使用变量名访问这块区域，因此，每一个变量使用前必须要先申请（声明内容），才能用
例子：int I =100; float f=12.3f; heap 堆 stack 栈
变量分类：
按声明位置分类：
局部变量： 方法体内部声明的变量（包括形参） 方法体内部是指与方法对应的大括号内部
成员变量：在方法体外，类体内声明的变量
凡是在大括号里定义的变量，出了这个大括号就没有人认识了
按所属的数据类型划分：
基本数据类型
引用数据类型
例子：(不能运行)
public class TestVar{
static int j;
public void m(){
int i=0;
System.out.println(i);
System.out.println(j);
boolean b = false;
if (b){
System.out.println("b is true");
}
long longNum1 = 1111111111
}
}
Java基本数据类型
4类8种基本数据类型
逻辑型—boolean
逻辑运算，用于程序控制
只有两个值true或false
文本型—char
字符常量为单引号括起来的单个字符
采用Unicode编码，每个字符占两个字节
Java语言中允许使用转义字符'\'来将其后的字符转变为其它的含义
例如：char c2='\n';//'\n'代表换行符
整数型—byte short, int ,long
Java语言整型常量的3种表示形式：
十进制整数，如：12，-314，0。
八进制整数，要求以0开头，如：012.
十六进制数，要求0x或0X开头，如：0x12
Java语言的整型常量默认为int型，声明long型常量可以后加'l'或'L'
| 类型 | 占用存储空间 |
| byte | 1字节 |
| short | 2字节 |
| int | 4字节 |
| long | 8字节 |
public class TestVar2 {
public static void main (String[] args){
}
}
浮点数型—float,double
基本数据类型转换
Boolean类型不可以转换成其他的数据类型
整型，字符型，浮点型的数据在混合运算中相互转换，转换遵循以下原则：
容量小的类型自动转换为容量大的数据类型：数据类型按容量大小排序为：
byte,short,char ->int ->long ->float ->double
byte,short,char之间不会相互转换，他们三者在计算时首先会转换为int类型
容量大的数据类型转换为容量小的数据类型时，要加上强制转换符，但可能造成精度降低或溢出：使用时格外注意
有多种类型的数据混合运算时，系统首先会自动的将所有数据转换成容量最大的那种数据类型，然后再进行计算
实数常量默认为double 整数常量默认为int
程序的格式：（比算法还重要）
格式应该注意的问题：
-
大括号对齐
-
遇到{缩进，Tab/Shift+Tab
-
程序块之间加空行
-
并排语句之间夹空格
-
运算符两侧加空格
6.{前有空格
7.成对编程
运算符
Java语言支持的运算符
算术运算符：+ ，-，*，/，%，++，--
关系运算符：>,<,>=,<=,==,!=
逻辑运算符：!,&,|,^,&&,||
位运算符：&,|,^,~,>>,<<,>>>
赋值运算符：=
扩展运算符：+=,-=,*=,/=
字符串连接运算符：+
自加自减运算符程序：
public class Test {
public static void main (String args[]){
int i1 =10,i2=20;
int i =(i2++);
System.out.print("i="+i); 注意：
System.out.println(" i2="+ i2); ++-（--）
i =(++i2); 在前时先运算再取值
System.out.print ("i="+i); 在后时先取值再运算
System.out.println(" i2="+ i2);
i =(--i1);
System.out.print ("i="+i);
System.out.println(" i1="+ i1);
i=(i1--);
System.out.print ("i="+i);
System.out.println(" i1="+ i1);
}
}
表达式和语句
表达式是符合一定语法规则的运算符和操作数的序列
表达式的运算顺序
应按照运算符的优先级从高到低的顺序进行
优先级相同的运算符按照事先约定的结合方式运行
三目条件运算符：x?y:z 其中x为boolean类型表达式，先计算x的值，若为true,则整个三目运算结果为表达式y的值，否则整个运算结果为表达式z的值
语句
：If语句
例子：
public class Testif{
public static void main (String [] args){
int I =20;
if(i<20){
System.out.println("<20");
Sysem.out.println("<20");
}else if (i<40){
System.out.println("<40");
}else if (i>60){
System.out.println("i<60");
}else
System.out.println("i>60");
System.out.println("i>60");
}
}
For语句
：For(表达式1；表达式2；表达式3){语句…}
例子：
public class Test{
public static void main (String args[]){
long result = 0;
long f = 1;
for (int I =1; i<=10;i++){
f=f*I;
result +=f;
}
System.out.println("result = "+ result);
}
}
技巧：Tab shift+tab
While语句
break&continue 语句
break语句用于终止某个语句块的执行。用在循环语句体中，可以强行退出循环；
例子：
public class Test{
int stop = 4;
for (int i =1;i<=10;i++){
if (I == stop) break;
System.out.println(" i= "+i);
}
}
}
continue 语句用在循环语句中，用于终止某次循环过程，跳出循环中continue语句下面未执行的循环，开始下一次循环过程。
例子：
public class Test{
public static void main (String args[]){
int skip =4;
for (int I =1;i<=5;i++){
if (i==skip) continue;//当i等于skip时，跳过循环
System.out.println("i="+i);
}
}
}
switch 语句
switch(){ 注意：
case xx: 小心case穿透，推荐使用break语句
…
case xx: java中switch语句只能探测int类型（char short byte 也可以）
….
default:
….
}
分支
方法
变量的作用域
递归调用 (没有分支)
总结
面向对象编程（重中之重）
编程语言的发展
语言的发展是朝着人类更加容易理解的方面发展
面向过程的设计思想和面向对象的设计思想
面向对象中的设计思维：合适的方法应该出现在合适的类里面
在程序中当我碰到这个问题域中都有哪些对象他们的关系是什么 。
首先：在这个问题中有哪些类，有哪些对象
这些类和这些对象应该具有哪些属性和方法
类和类之间具有了哪些关系
面向对象的基本思想是，从现实世界中客观存在的事物出发来构造软件系统，并在系统的构造中尽可能运用人类的自然思维方式。
面向对象更加强调运用人类在日常的思维逻辑中经常采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。
对象和类的概念
对象用计算机语言对问题域中事物的描述，对象通过"属性"和"方法"来分别对应事物所具有的静态属性和动态属性
类是用于描述同一类型的对象的一个抽象的概念，类中定义了这一类对象所应具有的动态和静态属性。
类可以看成一类对象的模版，对象可以看成该类的一个具体实例。
类之间的关系
关联关系（最弱的关系）
继承关系（一般和特殊） 封装了xx是一种XX ,能说通就可以
运动员可以派生出一棵继承树
聚合关系 （整体和部分）
聚集：相互关系不是特别紧密。
组合是一种密不可分的关系。
实现关系：
多态
对象和引用
Java与面向对象
对象是java程序的核心，java程序中"万事万物皆对象"。
对象可以看成是静态属性（成员变量）和动态属性（方法）的封装体。
类是用来创建同一类型的对象的"模版"，在一个类中定义了该类对象所应具有的成员变量以及方法。
JSDK提供了很多类供编程人员使用，编程人员也可以定义自己的类。
为什么用对象？？
面向对象的编程—一组对象互相配合通过沟通完成特定功能。
所有的paradigm都是对现实问题的抽象
汇编是对机器语言的抽象。
面向过程的语言是对汇编的抽象
对象更加符合对于现实问题的抽象
对象都有对外服务的接口
通过继承可以复用
对象隐藏内部服务的实现
通过聚合可以复用
面向对象更容易使我们达到这些年来苦苦追求的境界
Reusable、Extensibility、维护和替换更加方便、…….
组件—比对象更高的层次上的抽象（二进制级别）
EJB、Web Service、CORBA、COM、…
Java类定义
//用class关键字定义一个类，例如：
class Person {
//成员变量定义
private int id ;
private int age = 20;
//方法定义
public int getAge(){return age;}
public void setAge(int i) {age = I;}
public int getId() {return id ;}
类的定义主要有两方面组成——成员变量和方法。
声明成员变量的格式为：[<modifiers>]type < atr_name>[=defaultValue];
例如： private int id ; private int age =20;
声明方法的格式为：
[<modifiers>]<modifiers><return_type><name>([<argu_list>]){
[<statements>]
} 例如： public int getAge() {return age;}
成员变量 声明 赋值 使用
成员变量可以使用Java语言中任何一种数据类型（包括基本数据类型和引用类型）。
在定义成员变量时可以对其初始化，如果不对其初始化，java使用默认的值对其初始化。
成员变量的作用范围为整个类体。
| 成员变量类型 | Byte | Short | int | long | char | float | double | Boolean | 所有引用类型 |
| 取值 | 0 | 0 | 0 | 0l | '\u0000' | 0.0F | 0.0D | false | null |
Java面向对象基本概念 — 引用 c和c++的指针
Java语言中除基本类型之外的变量类型都称之为引用类型。
Java中的对象是通过引用对其操作的。
类和对象的关系
构造函数
使用new + 构造方法 创建一个新的对象
构造函数是定义在Java类中的一个用来初始化对象的函数。
构造函数与类同名
例如：Person 类的构造函数
public class Person {
int id;
int age;
Person (int n,int i){
id = n;
age = i;
}
}
构造函数
创建对象时，使用构造函数初始化对象的成员变量。
public class Test {
public static void main(String args[]){
Person tom = new Person(1,25);
Person john = new Person (2,27);
}
}
方法执行完了之后，局部变量就会消失
当没有指定构造函数时，编译器为类自动添加形如 类名（）{ }的构造函数。一旦指定，不会自动添加
例如：
class Point {
public int x;
public int y;
}
…… …… …….
Point p = new Point();
… … …
约定俗成命名规则
类名的首字母大写
变量名和方法名的首字母小写
运用驼峰标识 HelloWord 驼峰标识
内存解析
class BirthDate { //包装了生日
private int day;
pivate int month;
private int year;
public BirthDate(int d,int m,int y){ //构造方法
day = d;
month = m;
year = y;
}
public void setDay(int d) {
day =d ;
}
public void setMonth(int m){
month = m;
}
public void setYear(int y) {
year = y;
}
public int getDay(){
return day;
}
public int getMonth(){
return month;
}
public int getYear(){
return year;
}
public void display(){
System.out.println(day+" - "+month+" - "+year);
}
public class Test {
public static void main (String args[]){
Test test = new Test(); //test局部变量 自动构造一个test函数
int date = 9; //基础类型
BirthDate d1 = new BirthDate(7,7,1970);
BirthDate d2 = new BirthDate(1,1,2000);
test.change1(date);
test.change2(d1); //无法改变d2的值
test.change3(d2); //堆内存中的值发生了改变
System.out.println("date="+ date);
d1.display();
d2.display();
}
public void change1 (int 1){
i = -1234; //方法执行后，局部变量所占内存消失（栈内内存）
}
public void change2(BirthDate b){
b = new Birthdate(22,2,2004);
}
public void change3(BirthDate b){
b.setDay(22);
}
}
调用前： 调用后：
分析程序时从main方法开始分析.
定义一个"点"（Point）类用来表示三维空间中的点（有三个坐标）。要求如下：
-
可以生成具有特定坐标的点对象。
-
提供可以设置三个坐标的方法。
-
提供可以计算该"点"距原点距离平方的方法。
-
编写程序验证上述三条。
程序:
TestPoint.java
class Point{
double x,y,z;
Point (double _x,double_y,double_z){
x=_x;
y=_y;
z=_z;}
void setX(double_x){
x=_x;}
void setY(double y){
y=_y;
}
void setZ(double z){
z=_z;
}
double getDistance(Point p){
return (x-p.x)*(x-p.x)+(y-p.y)*(y-p.y)+(z-p.z)*(z-p.z);
}
}
public class TestPoint{
public static void main (String[] args){
Point p = new Point (1.0,2.0,3.0);
Point p1 = new Point(0.0,0.0,0.0);
System.out.println(p.getDistance(p1));
p.setX(5.0);
System.out.println(p.getDistance(new Point(1.0,1.0,1.0)));
}
}
方法的重载（overload）
方法的重载是指一个类中可以定义相同的名字，但参数不同的多个方法。调用时，会根据不同的参数表选择对应的方法。
构造方法的重载
与普通方法一样，构造方法也可以重载。
对象的创建和使用
必须使用new关键字创建对象。
使用对象（引用）.成员变量或来引用对象的成员变量。
使用对象（引用）.方法（参数列表）来调用对象的方法。
同一类的每个对象有不同的成员变量存储空间。
同一类的每个对象共享该类的方法。
非静态方法是针对每个对象进行调用。
分析复杂的式子时从里到外进行分析。
this关键字
在类的方法定义中使用的this关键字代表使用该方法的对象的引用。
当必须指出当前使用方法的对象是谁时使用this
有时使用this可以处理方法中成员变量和参数重名的情况。
This 可以看作是一个变量，它的值是当前对象的引用。
public class Leaf {
int i = 0;
Leaf (int i) {this .i=i;} 成员变量和参数重名
Leaf increament(){
i++;
return this;
}
void print() {System.out.println("i = "+i);}
public static void main (String[] args){
Leaf leaf = new Leaf(100);
leaf.increament().increament().print();
}
}
static 关键字
在类中，用static声明的成员变量为静态成员变量，它为该类的公用变量，在第一次使用时被初始化，对于该类的
所以对象来说，static成员变量只有一份。
用static声明的方法为静态方法，在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员。
静态方法不再是针对于某个对象调用，所以不能访问非静态成员 cat.(静态方法不用写静态变量的名字)
可以通过对象引用或类名（不需要实例化）访问静态成员。
public class Cat{
private static int sid = 0;
private String name;
int id;
Cat (String name){
this.name = name;
id = sid ++;
}
public void info (){
System.out.println("My name is "+ name+"No."+id);
}
public static void main (String arg[]){
Cat.sid = 100;
Cat.mimi =new Cat("mimi");
Cat.pipi = new Cat ("pipi");
mimi.info();
pipi.info();
}
}
局部变量在栈里，分配内存在堆里。静态的东西在数据区。代码在代码区。
package 和 import 语句
为便于管理大型软件系统中目众多类的类，解决类的命名冲突问题，Java引入包（package）机制，提供类的多重类命名空间。
package 命名为公司域名倒着来就是包名。
package 语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。（若缺省该语句，则指定为无名包）。
package pkg1[.pkg2[.pkg3…]];
Java编译器把包对应于文件系统的目录管理，package语句中，用'.'来指明包（目录）的层次，例如使用语句
package com.sxt;
则该文件中所以的类位于.\com\sxt目录下。
注意：
如果把一个类放到包里面，第一句必须是package,想跟多少从包，跟多少。将编译出来的class文件按照包的目录层次放到正确的位置下。
如果想要在另一个类中用包中的类，必须把包的名字写全。
如果将一个类打包，则使用该类时，必须使用该类的全名（例如：com.sxt.MyClass）,Java编译器才会找到该类。
也可以使用import在文件的开头引入要使用到的类；例如：
import com.sxt.MyClass;
import java.util.*;//引入java.util包中所有的类
… …. ….
MyClass myClass = new MyClass();//可以直接使用类名
…… ……..
可以不需要用import语句直接使用java.lang包中的类。
总结：
1.如果想将一个类放入包中，在这个类源文件第一句写package;
2.必须保证该类的class文件位于正确目录下
该类的源码可能会产生影响
删除或转移到另外的目录
3.另外的类想访问的话：
写全名
引入
*
具体类名
访问位于同一个包中的类不需要引入
4.必须class文件的最上层包的父目录位于classpath下。
5.执行一个类要写全包名。
J2SDk中主要的包的介绍
java.lang —包含一些Java语言的核心类，如String、Math、Integer、System和Thread,提供常用功能
java.awt —包含了构成抽象窗口工具集的多个类，这些类被用来构建和管理应用程序的图形用户界面
java.applet—包含applet运行所需要的一些类。
java.net-包含执行与网络相关的操作的类。
java.io—包含能提供多种输入/输出功能的类。
java.util—包含一些实用工具类，如定义系统特性、使用与日期日历相关的函数。
jar –cvf xx.jar*.*（打包jar包）
查看哪些重要的包：jdk5.0\jre\lib\rt.java里面就有
访问控制 （先讲继承）
Java权限修饰符 public protected private 置于类的成员定义前，用来限定其他对象对该类对象成员的访问权限。
| 修饰符 | 类内部 | 同一个包 | 子类 | 任何地方 |
| private | yes | | | |
| default | yes | Yes | | |
| protected | Yes | Yes | yes | |
| public | Yes | yes | Yes | yes |
对于class的权限修饰只可以用public和default
public类可以在任意地方被访问
default类只可以被同一个包内部的类访问。
public class TestAcess{
}
class T{
private int i =0;
int j =0;
protected int k =0;
public int m=0;
}
class TT{
public void m(){
T t =new T();
System.out.println(t.i+t.j);
}
类的继承
Java中使用extends 关键字实现类的继承机制，其语法规则为：
<modifier> class<name>
[extends< superclass>]{……}
通过继承，子类自动拥有了基类（superclass）的所有成员（成员变量和方法）
Java只支持单继承，不允许多继承：一个子类只能有一个基类 一个基类可以派生出多个子类。
//继承中的权限控制
class Parent{
private int n_private =1;
int n_friendly =2;
protected int n_protected = 3;
public int n_public =4;
}
class Child extends Parent {
public void f(){
n _private =10;//不能访问。有访问权，没有修改权
n_friendly =20；
n_protected =30;
n_public =40;
}
}
方法的重写
在子类中可以根据需要对从基类中继承来的方法进行重写。
重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型。
重写方法不能使用比被重写方法更严格的访问权限。
重写时从前面copy
class Person{
}
class Student extends Person{
}
public class TestOverWrite {
public static void main (String arg[]){
}
}
Super 关键字
在java类中使用super来引用基类的成份：例如：
class FatherClass{
public int value;
public void f(){
value = 100;
System.out.println("FatherClass.value="+value);
}
}
class ChildClass extends FatherClass{
public int value;
public void f(){
super.f();
value = 200;
System.out.println("ChildClass.value="+value);
System.out.println(value);
System.out.println(super.value);
}
}
public class TestInherit{
public static void main (String[] args){
ChildClass cc = new ChildClass();
cc.f();
}
}
继承中的构造方法
1.子类的构造的过程中必须调用其基类的构造方法。
2.子类可以在自己的构造方法中使用super(argument_list)调用基类的构造方法。
使用this(argument_list)调用本类的另外的构造方法
如果调用super,必须写在子类构造方法的第一行。
3.如果子类的构造方法中没有显示地调用基类构造方法，则系统默认调用基类无参数的构造方法。
4.如果子类构造方法中既没有显式调用基类构造方法，而基类中又没有无参的构造方法，则编译出错。
课堂练习：
练习一 ：分析输出结果，体会构造函数和一般成员函数在继承中的区别。
class A{
protected void print (String s){
System.out.println(s);
}
A() {print("A()");}
public void f() {print("A:f()");}
}
class B extends A {
B() {print("B()");}
public void f() {print("B:f()");}
public static void main (String arg[]){
B b = new B(); b.f();
}
输出：A() B() b B:f()
练习二：
class Person{
private String name;
private string location;
Person (String name){
this.name = name;
location = "beijing";
}
Person(String name ,String location){
this.name = name;
this.location = location;
}
public String info(){
return "name: " + name+ " location:"+location;
}
class Student extends Person{
private string school;
student (String name,String school){
this(name,school,"beijing");
}
Student(String n , String l, String school){
super(n,1);
this.school = school;
}
public String info(){
return super.info()+"school:"+school;
}
}
public class Test {
public static void main (String[] args){
Person p1 = new Person("A");
Person p2 = new Person("B","shanghai");
Student s1 = new Student("C","S1");
Student s2 = new Student("C","shanhai","S2");
System.out.println(p1.info());
System.out.println(p2.info());
System.out.println(s1.info());
System.out.println(s2.info());
}
}
练习三：根据上面的程序，构造"Teacher"类，继承"Person"类。要求：
- 增加"职称（String）"属性。
- 具有和"Student"类类似的重载构造方法。
- 重写"Person"类的info()方法，增加"职称"信息。
final关键字
Object 类
Object类是所有Java类的根基类 (API文档 中英文对照看最好)
如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类
public class Person{
….
}
等价于：
public class Person extends Object {
….. }
看文档
To String方法 （建议重写）
Object类中定义有public String toString()方法，其返回值是String类型，描述当前对象的有关信息。
在进行String与其它类型数据的连接操作时（如：System.out.println("info"+person)）,将自动调用该对象类的toString()方法
可以根据需要在用户自定义类型中重写toString()方法。
public class TestToString{
public static void main(String[] args){
Dog d = new Dog();
System.out.println("d:="+d.toString());
}
}
class Dog{
public String toString(){ //重写toString方法
return "I'm a cool Dog!";
}
}
equals方法
Object类中定义有：
public boolean equals(Object obj) 方法
提供定义对象是否"相等"的逻辑。
Object 的equals方法 定义为：x.equals(y)当x和y是同一对象的应用时返回true否则返回false
J2SDK 提供的一些类，如String，Date等，重写了Object的equals方法，调用这些类的equals方法，x.equals(y),当x和y所引用的对象是同一类对象且属性内容相等时（并不一定是相同对象），返回true否则返回false.
可以根据需要在用户自定义类型中重写equals方法。
public class TestEquals{
public static void main (String[] args){
Cat c1 = new Cat(1,2,3);
Cat c2 = new Cat(1,2,6);
Systtem.out.println(c1==c2);
System.out.println(c1.equals(cat));
}
}
Class Cat{
int color ;
int height, weight;
public Cat(int color ,int height,int weight){
this.color = color;
this.height = height;
this.weight = weight;
}
Public Boolean equals(Object obj){ //重写方法
if(obj ==null) return false;
else{
if(obj instanceof Cat){
Cat c = (Cat)obj;
If(c.color==this.color && c.height == this.height && c.weight == this.weight){
return true;
}
}
}
Return false;
}
对象转型
一个基类的引用类型变量可以"指向"其子类的对象。
一个基类的引用不可以访问其子类对象新增加的成员（属性和方法）。
可以使用引用变量instanceof类名 来判断该引用型变量所"指向"的对象是否属于该类或该类的子类。
子类的对象可以当作基类的对象来使用称作向上转型，反之称为向下转型
对象转型实例
class Animal{
public String name;
Animal （String name）{
this.name=name;
}
}
class Cat extends Animal{
public String eyesColor;
Cat(String n,String c) {
super(n);eyesColor=c;
}
}
class Dog extends Animal{
public String furColor;
Dog(String n,String c){
Super(n);furColor =c;
}
}
public class Test {
public static void main (String args[]){
Animal a=new Animal("name");
Cat c =new Cat("catname","blue");
Dog d = new Dog ("dogname","black");
System.out.println(a instanceof Animal);//true
System.out.println(b instanceof Animal);//true
System.out.println(c instanceof Animal);//true
System.out.println(a instanceof Cat);//false
a = new Dog("bigyellow","yellow");
System.out.println(a .name);//bigyellow
System.out.println(a.furname);//!error
System.out.println(a instanceof Animal);//true
System.out.println(a instanceof Dog);//true
Dog d1 = (Dog)a;//要加强制转换符
System.out.println(d1.furColor);//yellow
}
}
对象转换实例2 (可扩展性)
public class Test{
public static void main (String args[]){
Test test = new Test();
Animal a = new Animals("name");
Cat c =new Cat("catname","blue");
Dog d = new Dog("dogname","black");
Test.f(a);
Test.f(c);
Test.f(d);
}
Public void f(Animal a){
System.out.pringtn("name: "+a.name);
if(a instanceof Cat){
Cat cat = (Cat)a;
System.out.println(" "+cat.eyesColor+" eyes");
} else if (a instanceof Dog) {
Dog dog = (Dog)a;
System.out.println(" "+dog.furColor+ " fur");
}
多态和动态绑定
动态绑定是指"在执行期间（而非编译期）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
class Bird extends Animal {
private String featherColor;
Bird(String n,String f){
super(n);
featherColor = f;
}
public void enjoy(){
System.out.println("鸟叫声……");
}
}
public class Test{
public static void main (String args[]){
Lady 13 = new Lady
("13",new Bird("birdname","green"));
13.myPetEnjoy();
}
上面例子中，根据Lady对象的成员变量pet所引用
class Animal{
private String name;
Animal (String name) {
this.name=name;}
public void enjoy(){
System.out.println("叫声……….");
}
//public abstract void enjoy();
class Cat extends Animal(
private String eyesColor;
Cat(String n,String c){super(n);eyesColor = c;}
public void enjoy(){
System.out.println("猫叫声……");
}
}
class Dog extends Animal {
private String fucolor;
Dog(String n, String c) {super(n);fuColor=c;}
public void enjoy(){
System.out.println("狗叫声……")
}
}
class Lady{
private String name;
private Animal pet;
Lady(String name,Animal pet){
this.name = name;this.pet=pet;
}
public void myPetEnjoy(){pet.enjoy();
}
}
public class Test{
public static void main (String args[]){
Cat c = new Cat("catname","blue");
Dog d =new Dog("dogname","black");
//Bird b=new Bird();
Lady l1 = new Lady("11",c);
Lady l2 = new Lady("l2",d);
//Lady l3 = new Lady("l3",b);
11.myPetEnjoy();
12.myPetEnjoy();
//13.mypetEnjoy();
}
}
抽象类
用abstract关键字来修饰一个类时，这个类叫做抽象类：用abstract来修饰一个方法时，该方法叫做抽象方法。
含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写。
抽象类不能被实例化。
抽象方法只需声明，而不需实现。
abstract class Animal {
private String name;
Animal (String name){
This.name=name;
}
public abstract void enjoy();
}
class Cat extends Animal {
private String eyesColor;
Cat(String n,String c){
Super(n);eyesColor=c;
}
public void enjoy() {
System.out.pintln("猫叫声………");
}
}
Final关键字
final的变量的值不能够改变
final的成员变量
final的局部变量（形参）
final的方法不能够被重写
final的类不能够被继承。 Testfinal.java
接口
多个无关的类可以实现同一个接口
一个类可以实现多个无关的接口。
与继承关系类似，接口与实现类之间存在多态性。
定义Java类的语法格式：
<modifier> class <name> [extends <superclass>]
[implements <interface>[,<interface>]*]{
<declarations>*}
接口（interface）是抽象方法和常量值的定义的集合。
从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。
接口定义举例：
public interface Runner{
public static fina int id =1;// public static fina 写不写都一样
public void start();
public void run();
public void stop();
}
接口的特性：
接口可以多重实现；
接口中声明的属性默认为public static final的，也只能是public static final 的。
接口中只能定义抽象方法，而且这些方法默认为public的，也只能是public的。
接口可以继承其他的接口，并添加新的属性和抽象方法。
interface Singer{//定义接口
public void sing();
public void sleep();
}
class Student implements singer{ //实现接口
private String name;
Student (String name){
this.name=name;
}
public void study(){//实现方法
System.out.println("studying");
}
public String getName(){ return name;}
public void sing(){
System.out.println("student is singing");
}
public void sleep(){
System.out.println("student is sleeping");
}
}
举例 多个无关的类可以实现同一个接口
interface Singer{
public void sing();
public void sleep();
interface Painter{
public void paint();
public void eat();
}
class Student implements Singer{
private String name;
Student(String name) {this.name=name;}
public void study(){System.out.println("studying");}
public String getName(){return name;}
public void sing() {System.out.println("student is singing");}
public void sleep() {System.out.println("student is sleeping");}
}
class Teacher implements Singer,Painter{
private String name;
public String getString(){
return name;
}
Teacher(String name){this.name = name;} //一个类可以实现多个接口
public void teach(){System.out.println("teaching");}
public void sing(){System.out.println("teacher is singing");}
public void sleep(){System.out.println("teacher is sleeping");}
public void paint(){System.out.println("teacher is painting");}
public void eat(){System.out.println("teacher is eating");}
}
public class Test{
public static void main(string args[]){
Singer s1=new Student)("le");
s1.sing()=s1.sleep();
Singer s2 = new Teacher("steven");
s2.sing();
s2.sleep();
Painter p1 = (Painter)s2;
p1.paint();
p1.eat();
}
}
例子：
public interface TestValuable{//接口需要与.java文件相同
}
interface Protectable{
}
interface A extends Protectable{
}
abstract class Animal1{
}
class GoldenMonkey extends Animal1 implements TestValuable,Protectable{
JAVA异常处理机制
Java异常概念
运行期出现的错误 观察错误的名字和行号最重要。（程序是调试出来的）
异常的概念：
Java异常是java提供的处理程序中错误的一种机制。
所谓错误是指在程序运行的过程中发生的一些异常事件(如：除0溢出，数组下标越界，所要读取的文件不存在)。
设计良好的程序应该在异常发生时提供处理这些错误的方法，使得程序不会因为异常的发生而阻断或产生不可预见的结果。
Java程序的执行过程中如出现异常事件，可以生成一个异常类对象，该异常对象封装了异常事件的信息并将被提交给Java运行时系统，这个过程称为抛出（throw）异常。
当Java运行时系统接收到异常对象时，会寻找能处理这一异常的代码并把当前异常对象交给其处理，这一过程称为捕获(catch)异常。
public class Test{
public static void main (String[] args){
String friends[]={"Tom","John","Jenni"};
for (int I = 0;i<4;i++) {
System.out.println(friends[i]);
}
System.out.println("\n this is the end ");
}
}
b
Java异常分类
Error:称为错误，由Java虚拟机生成并抛出，包括动态链接2失败、虚拟机错误等，程序对其不做处理。
Exception：所以异常类的父类，其子类对应了各种各样可能出现的异常事件，一般需要用户显示的声明或捕获。
Runtime Exception:一类特殊的异常，如被0除、数组下标超范围等，其产生比较频繁，处理麻烦，如果显示的声明或捕获将会对程序可读性和运行效率影响很大。因此由系统自动检测并将它们交给缺省的异常处理程序（用户可不必对其处理）。
异常的捕获和处理
try{
//可能抛出异常的语句
}catch(SomeException1 e)
{
…. …. …
}catch (SomeException2 e)
{
… … …
}finally{
….. ….. …..
]
try 语句
try{…}语句指定了一段代码，该段代码就是一次捕获并处理例外的范围。
在执行过程中，该段代码可能会产生并抛出一种或几种类型的异常对象，它后面的catch语句要分别对这些异常做出相应的处理。
如果没有例外产生，所有的catch代码段都被略过不执行。
Catch语句
在catch语句块中是对异常进行处理的代码，每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。
在catch中声明的异常对象（catch（SomeException e））封装了异常事件发生的信息，在catch语句块中可以使用这对象的一些方法获取这些信息。
例如：
getMessage()方法，用来得到有关异常事件的信息。
printStackTrace()方法，用来跟踪异常事件发生时执行堆栈的内容。
finally 语句
finally语句为异常处理提供一个统一的出口，使得在控制流程转到程序的其他部分以前，能够对程序的状态作统一管理。
无论try所指定的程序块中是否抛出例外，finally所指定的代码都要被执行。
通常在finally语句中可以进行资源的清除工作，例如：
关闭打开的文件
删除临时文件。
对于捕捉到的异常一定要做出处理，打印相关信息。
五个关键字try catch finally throw throws
代码：
public class Test {
public static void main (String args[]){
Test test = new Test();
try{
test.method1();
} catch (SomeException e){
e.printStackTrace();
}
}
public void method1()
throws SomeException{method2();}
public void method2()
throws SomeException(method3();)
public void method3()throws SomeException{
throw new SomeException("SomeException occur in method3");
}
}
例子：
public class Test{
public static void main (String args[]){
String[][]s = new String[5][];
try{
s[1][0] = "hello";s[1][1]="你好";
}catch (NullPointerException e) {
System.out.println("数组元素没有正确实例化")；}
try{
s[5] = new String[3];
s[5][1]="hello";
}catch (Exception e2){
System.out.println("数组下标越界了");
} catch (ArrayIndexOutOfBoudsExce
System.out.println("有异常发生了")；
}
}
}
}
使用自定义的异常
使用自定义异常一般有如下步骤：
-
通过继承java.lang.Exception 类声明自己的异常类。
-
在方法适当的位置 生成自定义异常的实例，并用throw语句抛出。
-
在方法的声明部分用throw语句声明该方法可能抛出的异常。
class MyException extends Exception {
private int id ;
public MyException(String message,int id){
super(message);
this.id=id;
}
public int getId(){
return id;
}
}
public class Test{
public void regist(int num) throws MyException{
if(num < 0){
throw new MyException("人数为负值，不合理"，3)； 抛出异常后后面语句不会执行
}
Syste.out.println("登记人数"+num);
}
public void manager(){
try {regist(100);}
catch (MyException e){
System.out.println
("登记失败，出错类型码="+e.getId());
e.printStackTrace();
}
System.out.print("操作结束")；
}
public static void main (String[] args){
Test t = new Test();
t.manger();
}
}
声明并抛出异常
注意： 重写方法需要抛出与原方法所抛出异常类型一致或不抛出异常
数组
数组概述：
数组可以看成是多个相同类型数据组合，对这些数据的统一管理。
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
数组中的元素可以是任何数据类型，包括基本类型和引用类型。
一维数组的声明和初始化
一维数组的声明方式：
type var[];或 type[] var;
例如：
int a1[]; int[] a2; double b[]; Person[] p1; String s1[];
Java语言中声明数组时不能指定其长度（数组中元素的个数），例如： int a[5];//非法。
数组对象的创建
Java中使用关键字 new 创建数组对象，格式为：
数组名 = new 数组元素的类型 [数组元素的个数]
例子：
public class Test{
public static void main (String args[]){
int[] s;
s = new int[5];
for (int i =0;i<5;i++){
s[i]=I;
}
}
}
元素为引用数据类型的数组
注意：元素为引用数据类型的数组中的每一个元素都需要实例化。
public class Test{
public static void main (String args[]){
Date[] days;
days = new Date[3];
for (int i =0;i<3;i++){
days[i]=new Date(2004,4,i+1);
}
}
}
class Date {
int year; int month ;int day;
Date(int y ,int m,int d){
year=y;month =m;
day =d;
}
}
数组初始化
动态初始化
数组定义与为数组元素分配空间和赋值的操作分开进行。
public class Test {
public static void main (String args[]){
int a[];
a = new int[3];
a[0]=3;a[1]=9;a[2]=8;
Date days[];
days = new Date[3];
days[0]=new Date(1,4,2004);
days[1]=new Date(2,4,2004);
days[2]=new Date(3,4,2004);
}
}
class Date{
int year,mont,day;
Date(int y,int m, int d){ year =y;month= m;day =d;
}
}
静态初始化
在定义数组的同时就为数组元素分配空间并赋值，例如:
public class Test{
public static void main(String args[]){
int a[] ={3,8,9};
Date days[] ={
new Date(1,4,2004),
new Date(2,4,2004),
new Date(3,4,2004);
}
}
}
class Date {
int year,month,day;
Date(int y,int m,int d){
Year = y;month = m;day =d;
}
}
数组元素的默认初始化
数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐式初始化。
数组元素的引用
定义并用运算符new为之分配空间后，才可以引用数组中的每个元素，数组元素的引用方式为：
arrayName[index]
index为数组元素下标，可以是整型常量或整型表达式。如：a[3],b[i],c[6*i].
数组元素下标从0开始：长度为n的数组的合法下标取值范围为0~n-1。
每个数组都有一个属性length指明它的长度，例如：
a.length的值为数组a的长度（元素个数）。
初学者应该先把程序写通再去考虑程序的健壮性和友好性。
二维数组的声明和使用
数组拷贝
Java常用类
字符串相关类（String、StringBuffer）
基本数据类型包装类
Math类
File类
枚举类
String 类
Java.lang.String类代表不可变的字符序列。
"xxxxx"为该类的一个对象。
String类的常见构造方法：
String(String original) 创建一个String对象为original的拷贝
String(char[] value)
用一个字符数组创建一个String对象
String(char[] value,int offset,int count)
用一个字符串数组从offset项开始的count个字符序列创建一个String对象
String 类举例
public class Test{
public static void main(String[] args){
String s1="hello";String s2="world";
String s3="hello";
System.out.println(s1 == s3);//true
s1=new String("hello");
s2=new String("hello");
System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//true equals 比较，重写了String方法
char c[]={'s','u','n',' ','j'.'a','v','a'};
String s4=new String(c);
String s5 = new String(c,4,4);
System.out.println(s4);//sun java
System.out.println(s5);//java
}
}
String 类常用方法（1）
public char charAt(int index)
返回字符串中的第index个字符
public int length()
返回字符串的长度
public int index0f(String str)
返回字符串中出现str的第一个位置
public int index0f(String str, int fromIndex)
返回字符串中从fromIndex开始出现str的第一个位置
public Boolean equalsIgnoeCase(String another)
比较字符串与another是否一样
public String replace(char oldChar,char newChar)
在字符串中用newChar字符替换oldChar字符
String 类 常用方法（2）
静态重载方法
public static String valueOf(…)可以将基本类型数据转换为字符串；
例如：
public static String valueOf(double d)
publc static String valueOf(int i)
方法 public String[] split(String regex)可以将一个字符串按照指定的分隔符分隔，返回分隔后的字符串数组。
String 类举例（4）
public class Test{
public static void main(String[] args){
int j =1234567;
String sNumber = String.valueOf(j);
System.out.println("j是"+sNumber.length()+"位数")；
String s= "Mary,F,1975";
String[] sPlit =s.split(",");
for(int i = 0;i<split.length;i++){
System.out.println(sPlit[i]);}
}
}
练习：
编写一个方法，返回一个double型二维数组，数组中的元素通过解析字符串参数获得，如字符串参数："1,2,3,4,5,6,7,8" 对应的数组为：
d[0,0]=1.0 d[0,1]=2.0
d[1,0]=3.0 d[1,1]=4.0 d[1,2]=5.0
d[2,0]=6.0 d[2,1]=7.0 d[2,2]=8.0
需要注意的一些情况：
要把自己会写的一些东西写出来不要只看而不动手 水平有限
调试时 需要不断的打印来验证程序的正确与否
写程序不求一下子就能够写出来而是不断的添加
package ShuZu;
public class ArrayParser {
public static void main (String args[]){
//System.out.println(sFirst[i]);//判断输出是否正确
}
for (int i= 0;i<d.length;i++){
}
}
}
总结：
Java容器类
容器的概念
JAVA API所提供的一系列类的实例，用于程序中存放对象 随机应变想大就大，想没就没
容器API
Collection接口
定义了取存一组对象的方法，其子接口set和list
Collection接口方法：
程序运行时：无法创建一个new Name（没有与name类放到一起）
容器类对象在调用remove、contaions等方法时需要比较对象是否相等，这会涉及到对象类型的equals方法和hasCode方法以实现自定义对象相等规则。
hashCode适合做索引
Iterator接口
所有实现了Collection接口的容器类都有一个iterator方法用以返回一个实现了Iterator接口的对象
Iterator对象称作迭代器，用以方便的实现对容器内元素的遍历操作
Iteerator接口定义了如下方法：
boolean hasNext(); //判断游标右边是否有元素
Object next();//返回游标右边的元素并将游标移动到下一个位置
void remove();//删除游标左面的元素，在执行完next之后该操作只能执行一次
增强for循环(不重要)
增强的for循环对于遍历array或Collection的时候非常遍历
缺陷：
数组：不能方便的访问下标值
集合：与使用Iterator相比，不能方便的删除集合中的内容 在内部也是调用Iterator
总结： 除了简单遍历并读出其中内容外，不建议使用增强for
Set接口
Set接口是Collection的子接口，set接口没有提供额外的方法，但实现Set接口的容器类中的元素是没有顺序的，而且不可以重复。
Set容器可以与数学中"集合"的概念相对应。
J2SDK API所提供的set容器类有HashSet,TreeSet等
List接口
List接口是Collection的子接口，实现list接口的容器类中的元素是有顺序的，而且可以重复。
List容器中的元素都对应一个整型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
JSDK所提供List容器中的元素有ArrayList LinkedList等。（equals）
List 常用算法
类 java.util.Collections 提供了一些静态方法实现了基于List容器的一些算法。
Compareable接口
问题：上面的算法根据什么确定容器中对象的"大小"顺序？
所有可以排序的类都实现了java.lang.Comparable 接口，Comparable接口中只有一个方法
public int compareTo(Object obj);该方法：
返回0 表示this==obj
返回正数表示 this>obj
返回负数表示this< obj
实现了Compareable 接口的类通过实现comparaTo方法从而确定该类对象的排序方式。
Map接口
实现Map接口的类用来存储键值对
Map接口的实现类有HashMap和TreeMap等（做索引）
Map类中存储的键——值对通过键来标识，所以键值不能重复（equals 比较是否重复时使用hashcode）
第一个返回对象时Object返回的是value
自动打包、解包
Auto-boxing/unboxing
在合适的时机自动打包、解包
自动将基础类型转换为对象
自动将对象转换为基础类型
泛型
起因：
JDK1.4以前类型不明确：
装入集合的类型都被当做Object对待，从而失去自己的实际类型
从集合中取出时往往需要转型，效率低，容易产生错误。
解决办法：
在定义集合的时候同时定义集合中对象的类型
示例：BasicGeneric.java
可以在定义Collection的时候指定
也可以在循环时用terator指定
好处：增强程序的可读性和稳定性
总结：
1136
一个图
一个类
Collection 封装了一些list的算法
三个知识点
For
Generic (泛型)
Auto-boxing/unboxing
六个接口
Java流技术
Java流式输入/输出原理
流是用来读取数据的。（类比流水）
读数据时通过管道连接程序与文件
对于数据的输入/输出操作以"流"（stream）方式进行;J2SDK提供了各种各样的"流"类，用以获取不同种类的数据，程序中通过标准的方法输入输出数据
Java流类的分类
输入/输出流的分类
Java.io包中定义了多个流类型（类或抽象类）来实现输入/输出功能：
按数据流的方向不同可以分为输入流和输出流(程序的角度)
按照处理数据单位不同可以分为字节流和字符流（一个字符是俩个字节）
按照功能不同可以分为节点流和处理流
J2SDK所提供的所有流类型位于包java.io内都分别继承以下四种抽象流类型
| | 字节流 | 字符流 |
| 输入流 | InputStream | Reader |
| 输出流 | OutputStream | Writer |
常见的节点流和处理流
套在其他流上的是处理流
所有以Stream结尾的都是字节流(字节流最原始)
文件流
InputStream
继承自Inputsteam的流都是用于向程序中输入数据，且数据的单位为字节（8bit）;深色节点流浅色处理流
InputStream的基本方法
OutputStream
继承自OutputSteam的流是用于程序中输入数据，且数据的单位为字节（8bit）；深色为节点流，浅色为处理流
OutputStream的基本方法
Reader
继承自Reader的流都是向程序中输入数据，且数据单位为字符（16bit） 深色为节点流，浅色为处理流
Reader的基本方法
Writer
继承自Writer的流都是向程序中输出数据，且数据单位为字符（16bit） 深色为节点流，浅色为处理流
Write的基本方法
节点流类型
处理流
缓冲流
缓冲流要"套接"在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法。
J2SDk提供了四种缓存流，其常用的构造方法为：
BufferedReader(Reader in)
BufferedReader(Reader in,int sz) //sz为自定义缓冲区的大小
BufferedWriter(Writer out)
BufferedWriter(Writer out,int sz)
BufferedInputStream(InputStream in)
BufferedInputStream(InputStream in , int size)
BufferedOutputStream(OutputStream out)
BufferedOutputStream(OutputStream out,int size)
缓冲输入流支持其父类的mark和reset方法
BufferedReader提供了readLine方法用于读取一行字符串（以\r或\n分隔）
BufferedWriter提供了newLine用于写入一个行分隔符
对于输出的缓冲流，写出的数据会先在内存中缓存，使用flush方法将会使内存中的数据立刻写出
数据流
代码见 TestDataStream.java
DataInputStream 和DataOutputStream 分别继承自InputStream和OutputStream，它属于处理流，需要分别"套接"在InputStream和OutputStream类型的节点流上。
DataInputStream和DataOutputStream提供了可以存取与机器无关的Java原始类型数据（如：int,double等）的方法
DataInputStream和DataOutputStream的构造方法为：
DataInputStream(InputStream in)
DataInputStream(OutputStream out)
转换流
InputStreamReader和outputStreamWriter用于字节数据到字符数据之间的转换
InputStreamReader需要和InputStream "套接"
OutputStreamWriter需要和OutputStreaam"套接"
转换流在构造时可以指定其编码集合。例如：
InputStream isr = new InputStreamReader(System.in,"ISO8859_1")
写true不写true 是对源数据是否进行覆盖
Printl流
PrintWriter和PrintStream都属于输出流，分别输出字符和字节。
PrintWriter和PrintStrream提供了重载print
Println方法用于多种数据类型的输出。
PrintWrite和PrintStream的输出操作不会抛出异常，用户通过检测错误状态获取错误信息。(写网页比较好)
PrintWriter和PrintStream有flush功能 （自动清空）
PrintWriter(Writer out)
PrintWriter(Writer out,boolean autoFlush)
PrintWriter(OutputStream out)
PrintWriter(OutputStream out,boolean autoFlush)
PrintStream(OutputStream out)
PrintStream(OutputStream out,booleanautoFlush)
Object流
直接将Object写入或读出
TestObjectIO.java
Transient关键字 透明的
Serializable接口 标记对象可以序列化
externalizable接口 自己控制序列化
总结
理解输入流输出流 字符流 字节流
Inputstream/Outputstream
Reader/writer/Writer
FileInputStream/FileoutputStream
FileReader/FileWriter
BufferedInputstream/bo
BufferedReader/BufferedWriter
Bytearrayinputstream/bytearrao
Inputstreamreader/outputstreamwriter
Datainputstream/out
PrintStream/PrintWriter
Objectinputstream/out
Java多线程机制
线程的基本概念
线程是一个程序内部的不同的执行路径（简单的定义）
定义：线程是一个程序内部的顺序控制流。
线程和进程的区别
每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销。
线程可以看成是轻量级的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC）,线程切换的开销小。
多进程：在操作系统中能同时运行多个任务（程序）
多线程：在同一应用程序中有多个顺序流同时执行
Java的线程是通过java.lang.Thread类来实现的。
VM启动时会有一个由主方法（public static void main(){}）所定义的线程。
可以通过创建Thread的实例来创建新的线程。
每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的，方法run()称为线程体。
通过调用Thead类的start()方法来启动一个线程。
线程的创建和启动
可以有两种方式创建新的进程
第一种
定义线程类实现Runnable接口
Thread myThread = new Thead(target)//target为Runnable接口类型
Runnable中只有一个方法：
public void run();用以定义线程运行体
使用Runnable接口可以为多个线程提供共享的数据
在实现Runnable接口的类的run方法定义中可以使用Thread静态方法：
public static Thread currentThread() 获取当前线程的引用。
第二种 (能使用接口就不要从父类继承)
可以定义一个Thread的子类并重写其run方法如：
class MyThread extends Thread{
public void run(){....}}
然后生成该类的对象：
MyThread myThjread = new MyThead(...) 多线程运行在运行main后又开启了一个进程 ，两者交替运行
线程的调度和优先级
线程的优先级别
线程的状态控制
线程状态转换
Sleep
例子：
线程同步
例子分析
Synchrinized(this) 锁定当前线程（互斥锁）
在java语言中引入了对象互斥锁的概念，保证共享数据操作的完整性。每个对象都对应于一个可称为"互斥锁"的标记，这个标记保证在任一时刻，只能有一个线程访问对象。
关键字synchronized来与对象的互斥联系。当某个对象synchronized修饰时，表明对象在任一时刻只能由一个线程访问。
synchornized的使用方法：
synchorized(this){
num++;
try{ Thread.sleep(1);}
catch(InterruptedException e) {}
System.out.println(name+",你是第"+num+"个使用timer的线程')；}
Synchronized 还可以放在方法声明中，表明整个方法为同步方法。例如：
Synchronized public void add(String name){...}
解决死锁的方法：（1）加大锁的粒度
Wait sleep区别
Wait识别的线程可以访问锁定对象
调用wait方法的时候必须锁定对象
Sleep时别的线程也不可以访问锁定对象
Java网络编程
网络编程不同于网站编程
网络基础
网络基础概念
网络通信协议：计算机网络中实现通信必须有一些约定
网络通信接口：
通信协议分层的思想：
为什么要分层：
由于结点之间很复杂，在制定协议时，把复杂成分分解成有一些简单的成分，再将它们复合起来。最常用的复合方式是层次方式，即同层间可以通信、上层可以调用下一层，而与再下一层不发生关系。各层互不影响，利于系统的开发和扩展。
通信协议的分层规定: 把用户应用程序作为最高层，把物理通信线路作为最底层，将其间的协议处理为若干层，规定每层处理的任务，也规定每层的接口标准。
TCP/IP协议
IP地址：
Socket
编写网络程序：server 与client一起写 通信依靠流 先启动server再启动client
UDP
不可靠
效率高
数据包/非连接
音频
视频
总结：
网络协议分层思想 IP的概念 TCP/UDP的概念 TCP/UDP程序的写法
GUI编程
AWT
AWT包括了很多类和接口，用于JavaApplication的GUI（Graphics User Interface图形界面用户）编程
GUI的各种元素（如：窗口，按钮，文本框 ）由Java类来实现
使用AWT所涉及的类一般在javav.awt包及其子类。
Container和Component是AWT中的两个核心类
组件和容器
布局和管理器
FlowLayout的构造方法
FlowLayout的构造方法
new FlowLayout(FlowLayout.RIGHT,20,40); 右对齐，组件之间水平间距20个像素，垂直间距40个像素
newFlowLayout(FlowLayout.LEFT); 左对齐，水平和垂直间距为缺省值（5）。
new FlowLayout(); 使用缺省的居中对齐方式，水平和垂直间距为缺省值（5）；
BorderLayout布局管理器
扫一扫
169
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
