--
分类： Java
2014-03-14 16:41:31
1、 设置好jdk路径（环境变量），classpath（运行至指定class）
Javac编译，Java运行 （命令，类似gcc）
2、hello.java
public class hello
{
public static void main(String args[])
{
System.out.println("Hello World!");
}
}
注意：类名必须和文件名一致，
2、 数据类型，和C类似，多个接口（interface）
String类型操作，所有字符串都可以“+”操作，字符串分开通过“+”拼起来
3、 java新特性：可变参数
public static void fun(int… arg)
{
For ( int i=0;i
{
System.out.println(arg[i] + “、”);
}
}
Java新特性：foreach输出，数组的for循环输出
4、 结构化程序设计：稳定性、可修改性、可重用性差，源于功能的分解，过程化程序设计
用户需求随时变化，所以结构化开发设计是灾难性的。
面向对象设计：封装性、继承性、多态性（3大特征）
许多不支持多继承，java通过接口（interface）弥补不支持多继承，子类不能享用多类的缺点。
类：属性+方法，创建类对象：person per = new person();
若person per1 = null；person per2 = null； per2 = per1；无论怎么复制，两对象都是相同的，指向同一块内存空间
封装性：set，get，将信息私有化，通过公开函数set、get对私有信息操作。
类中所有属性均要封装，private声明的属性或方法只能在类的内部调用，在类外面不能被调用。类中的函数调用直接可以使用this.set()实现调用。不要图省事不写，出错不好查错。
还可使用构造函数。
String数据类型：一种类，初始化两种方式，直接复制和构造函数初始化
字符串与字符数组的转换 字符串通过toCharArray()-à字符数组，字符数组通过 string类的构造函数把一个字符数组变为一个字符串。
Sting.equals(**)，比较字符串是否相同 true or false
String+** 字符串可以直接相加
String s1= “sdds”；char c[] = str1.toCharArray();
String s2 = new string(c);字符数组变为字符串
charAt(?)取出字符串指定位置的字符
string str.length()；获取字符串长度
string str1.indexOf(“sd”)查找字符串sd的位置
string.trim();去掉字符串的左右空格
string.substring(6)/substring(0,5)分别指从第七个开始截取，从0-5截取。
大小写转换：**.toUpperCase() toLowerCase()
判断字符串开头、结尾，**.startWith(“**”); **.endWith(“**”);
替换：**.replaceAll(“l”,”x”);将l全部替换为x
this用法：
1、构造函数初始化，this.name = name (含参构造函数中的变量)
2、构造函数（重构）之间的互相调用，this();含参调用不含参，只能放在构造函数首行
Static用法：
1、前面加static标识的为全局变量，所有对象共享，将批量修改的变量类型用static标识
Static count =0； count++，一经修改之后后面全部被修改
2、构造函数私有化，这样对象的实例化会出错，将对象实例化放在类当中，
Class A{static A aa = new A();} main(){ A aaa = A.aa}
对象数组：数组首先就要开辟空间,数组中都是对象，使用对象时需要实例化
Person per[] = new Person[3]
内部类：
第六章、 面对对象高级篇 ：
继承：class son extends father {}
Java 之允许单继承，不能多重继承，子类不能直接访问父类的私有成员，可以通过成员函数get返回需要的值。
成员函数的复写：被子类复写的函数权限缩小，会出错，方法复写需要考虑权限，若父类使用public权限，则子类必须是public，否则无法编译
本身this.**，父类的super.**
类名开头字母大写。
匿名对象：new Person(“**”,30).tell(); 没有任何栈内存引用，使用一次之后等待被垃圾回收机制进行回收。
final 关键字 可声明类、属性、方法，意思是最终也是完结器
不能有子类、方法不能被子类复写，final声明变量为常量，不可以修改
抽象类作用类似于模板，天生当爹
包含抽象方法的类必须为抽象类 用abstract关键字声明，抽象方法只需声明不需要实现
抽象类必须被子继承，子类复写抽象函数
Class B extends A{public B(){super(); **}}
接口： 由全局常量和公共的抽象方法组成，必须通过子类实现,抽象函数必须定义为public访问权限，
Interface A
{
Public static final String Author = “sdasd”;
Public abstract void print();
}
因接口必须是全局和抽象函数，可以去掉static,abstract,变为
Interface A
{
String name=”sda”;
void print();
}
Class A implements B,C{} 一个子类可以实现多个接口。摆脱了Java的单继承局限性。
子类既要实现接口又要继承抽象类：class 子类 extends 抽象类 implements 接口A,B{}
一个接口继承多个接口：interface C extends A，B{}
对象的多态性：（1）方法的重写；（2）对象的多态性
对象的多态性：（1）向上转型，子类——》父类（2）向下转型，父类——》子类
对象向上转型：父类 父类对象=子类对象；
对象向下转型：子类 子类对象 = （子类）父类对象
对象发生向上转型之后方法一定被子类复写过了，但是转型后父类不能调用子类的方法，只能调用父类的方法。
对象发生向上转型之后方法一定被子类复写过了，父类方法也可以调用。
Instanceof关键字 判断一个对象到底是哪个类的实例
对象 instanceof 类——》返回布尔值
抽象类与接口的应用 实现对象的多态性
抽象类的实际应用：模板设计
Person：name,age, 抽象方法：say()
Student继承person，加入score，复写say(),，同样道理，对于Worker
接口的实际应用——制定标准 ，是解决多继承局限的手段
例如：U盘和打印机都可以插在计算机使用
Interface USB{void start(); void stop();}
Class computer{static plgin(USB usb){usb.start(); usb.stop(); }}
Class Flash implemnts USB{复写start、stop}
Class Printer implemnts USB{复写start、stop}
Computer. Plgin(new Flash()); Computer. Plgin(new Printer());
设计模式：
1、工厂设计模式——使用最多的设计模式
水果——苹果，梨。。
子类为接口实例化，并复写方法
过渡端就是工厂类。
Interface Fruit{void eat();}
Class Apple implements Fruit{复写eat()}
Class OrangeApple implements Fruit{复写eat()}
Class Factory{ 类似于switch case。。
static Fruit getInstance(classname)
{ if (“apple”.eaqiles(calssname))而classn.equals(“apple”),避免空指针异常
Fruit f = new Apple();
……
Return f;;
}
}
2、代理模式 使用代理主题来操作真实主题，真实主题执行具体业务操作，代理负责其他相关业务的 处理，类似于代理上网
无论是代理还是真实用户操作，都是上网，用户关心如何上网，具体不关心，
Interface network{ void browse();}
Class real implements network {复写browse()}
Class daili implemnts netword {加入权限检查等，复写browse()}
Network nt = new daili(new real()); 代理不仅做了用户的东西，还做了更多内容
3、适配器设计模式
接口要复写所有方法，若方法过多，子类用不到这么多，需要中间过渡，但不希望被直接使用，定义为抽象类组合式。。子类不用实现接口所有方法，有选择性 的实现所需方法。
例如：interface window {
Void open(); void close(); void activated(); void …
}
Abstract class Windowadapter implements window
{
Void open(); void close(); void activated(); void …
}
Class win extends Windowadapter
{ 复写函数}
抽象类中也可以使用interface
抽象类与接口之间的关系
记住原则：一个类不要继承一个已经实现好的类，只能及策划那个抽象类或实现接口，若接口与抽象类都可使用，优先使用接口，避免但继承局限性。
第七章; 异常处理
try{} catch( 异常类 异常对象) {异常处理语句}
finally{一定会运行到的代码段}
异常类：算数异常：ArithmeticException A //
数组超出绑定异常：ArrayIndexOutOfBoundsException
数字格式化异常：NumberFormatException
最常用的类：Exception和Error均是Throwable的子类
Exception类：程序中的问题，使用try….catch 处理，，printStackTrace()输出异常信息
Error：JVM错误，程序无法处理。
Throws表示不管是否有异常，在调用此方法都必须进行异常处理。
例如：Public void **()throws Exception{**}
Throws与throw不同，throw可直接抛出一个异常,try{throw new Exception(“自己抛出异常”)}
Exception类与RuntimeException类：
Exception在程序中必须使用try …catch 进行处理
RuntimeException可以不使用try…catch进行处理，如有异常产生，异常由JVM进行处理。
NumberFormatException 属于RuntimeExcption子类
RuntimeException子类最好使用异常处理机制，可以不用try catch，但是一旦异常则肯定导致程序中断执行，所以最好使用try catch处理机制
断言：assert Boolean 表达式，虽然有检查运行结果的功能，但一般在开发中不提倡使用。
第八章 包及访问控制权限
为避免类的重名，静态加载包
命令行编译javac –d . **.java -d表示生成目录； 。表示在当前文件夹下生成
常见包：java.lang 基本包，String保存在此包，
Java.util 工具包，常见类库、日起操作在此包中，若此包精通，各种设计思路都很好理解
Java.txt 文本处理的类库
Java.Io java.net java.swing(图形用户界面，轻量级) java.awt(GUI界面)
Java命名规范：
（1） 类，所有单词首字母大写，例如；TestList
（2） 方法：首字母小写，其余单词首字母大写，例如：getInfo()
（3） 属性：首字母小写，其余单词首字母大写，例如：userName；
（4） 包：所有单词字母小写；
（5） 常量：所有单词字母大写，例如：FLAG
（6）
Java应用程序设计
第九章：线程与进程
线程的实现；
（1）继承Thread类，并明确复写Thread中run()
例如：class ** extends Thread
{ public void run(){;;;;;} }//仅仅是run方法并不能代表开启多线程。
**.start();// 才是真正的启动多线程
一个类继承Thread类来实现,只能调用一次start()，如果调用多次，则会抛出illegalThreadStateException异常
（2）实现Runnable接口，只定义了一个抽象方法，run() ,
Class MyThread implements Runnable
{
Public void run(){复写内容} //
}
myThread my1 = new MyThread(****);
Thread th1 = new Thread(my1); //类似与向上转向。
Th1.start();
Runnable接口相对于Thread类适用于多个线程处理同一资源的情况，可避免由于java但继承特性带来的局限，增强程序 的健壮性，代码被多线程共享，代码与数据独立。
线程运行，**.run() 阻塞运行，**.sleep()/suspend()/wait() 死亡 **.stop(),或run()执行结束
Java运行时至少启动2线程，一个是main线程，另一个是垃圾回收线程
Join()强制运行，其他线程无法运行
Sleep()休眠，单位为ms
Interrupt()中断，中断运行状态
SetDaemon()后台执行，
线程共享数据同步与死锁：
1、同步代码块：
Synchronized(对象){需要同步的代码块；}一般吧当前对象(this )设置为同步对象。
例如：synchronized (this)
{ /……同步的数据 }
2、同步方法；synchronized关键字将一个方法声明成同步方法
例如：synchronized 返回值 方法(参数列表){}
Class myThread implemnts Runnable
{ public void run(){…}
Public synchronized void sale() {….}
}
死锁：同步可以保证资源共享的正确性，过多同步会产生问题。
死锁就是两个线程都在等待彼此先完成，
Static型对象，数据共享
线程操作经典案例：生产者与消费者问题，，生产者一直产生数据，消费者一直读取数据
（1） 不同步问题：使用synchronized()方法
（2） 重复读取问题：Object类——等待与唤醒。加入wait()与notify()
Object类是所有类的父类，
方法：wait()含参与不含惨，可以指定最长等待时间
notify() notifyAll() 唤醒第一个/全部等待的线程
线程的生命周期：
Suspend()暂时挂起；resume()回复挂起；stop()停止线程，此三法不推荐使用。
如何停止线程：设置标志位停止线程的运行。
Class myThread implemnts Runnable{ Boolean flag；
Public void run() {复写}
Public void stop() {修改 标志位}
}
第十章 泛型
Object类可以存储任何数据类型，坐标的类，（X，Y）；整形和小数；或是东经西经这种
泛型的基本应用：解决数据类型的安全性问题，避免类型转换的异常发生，通过类声明时一个标志表示类中某属性的类型或是方法的返回值及参数类型。
[权限] class <泛型类型1,*2,*3>
{
[权限]泛型类型标志 变量名；
[权限]泛型类型标志 方法名() {}；
[权限]返回值类型声明 方法名(泛型类型标志 变量)；
}
泛型类对象定义：类名<具体类> 对象名 = new类名<具体类>();
把参数类型也作为参数传输到类中。
同样可以多属性，声明时指定多个泛型类型。Class notepad
通配符：不知道数据类型，info temp
第十一章 Java常用类库
1、StringBuffer类
String一旦被声明不可改变，通过+进行字符串的连接
StringBuffer用于经常改变，却只能用append方法进行连接
常用方法：
Append() 加内容
Insert() 在任意位置添加内容
Reverse().toString 字符串反转
Replace(开始，结束，“内容”)替换指定范围的内容，，String中替换使用replaceAll()
Delete(开始，结束) 删除
2、Runtime类
表示运行时操作类，封装了JVM进程的类，每一个JVM都对应一个Runtime类实例
取得一个Runtime实例的方法：Runutime run = Runtime.getRuntime();;
方法：gc()运行垃圾回收器，释放空间
exec(String Cmd)执行本机命令 例如：notepad.exe
3、Runtime类与Process类
Process类中方法：Process.destroy();
国际化程序：仅靠Local类是不够的，还需要属性和ResourceBundle类的支持。属性文件指后缀为.properties文件，内容结构为“key=value”形式。若要访问属性文件，使用ResourceBundle类来完成。
Java.util.Locale:用于表示一个国家语言类
Java.util.ResourceBundle:用于访问资源文件
Java.text.MessageFormat：格式化资源文件的占位字符串。
3个类通过Locale类所指定的区域码，之后ResourceBundle根据Locale类所指的区域码找到相应的资源文件。若资源文件中存在动态文本，使用MessageFormat进行格式化。
Locale类： Locale(String language),zh-CN en-US
ResourceBundle类，主要作用读取属性文件
常用方法：getBundle() getString(String key)
System类：system类中的方法都是静态的，使用时可以直接调用。
exit() 系统退出
gc() 运行垃圾回收机制，调用的就是Runtime类中的gc()方法 。一般很少直接调用，由系统来完成
日期操作类：
Date类---java.util.Date
Calender类：
方法：getInstance()实例化对象
get(int field)返回给定日历字段的值例如：YEAR、MONTH、MINUTE、SECOND
DateFormate类，抽象类，但有一个静态方法，
getDateInstance() 取得日期
getDateTimeInstance()取得日期时间
Arrays类是数组操作类。实现数组元素的查找、填充、排序。
常用方法：equals(int [] a1,int [] a2);比较是否相等
Sort(int [] a) 数组排序，
观察者设计模式
Observable类与Observer接口，使用他们即可完成观察者模式。需要被观察的类必须继承Observable类，常用方法：
addObserver(Observer o) 添加观察者 deleteObserver(Observer o) 删除观察者
每个观察者类需要实现Observer接口，
Public interface Observer{ void update(Observer 0,Object arg)}//参数1观察者实例，2为修改的内容
正则表达式：
方便的对数据进行匹配，还可以执行更复杂的字符串验证、拆分、替换等功能。
Pattern.compile(“[0-9]+”).matcher(字符串).matches() 验证字符串是否都是数字
由Pattern(正则规范)和Matcher(执行规范)两个类完成操作。
第十二章 Java IO
文件操作相关的类：File，，文件创建、删除
File(完整路径)，创建文件类对象；Linux与Win的路径表示法不同，使用File.separator便于系统的移植方便
.createNewFile()创建新文件
.delete()删除文件
.exists() 判断文件是否存在。
.mkdir() 创建目录
.list()列出指定目录下的全部文件 String str[],仅仅是文件名，不是全路径
.listFiles()；String str[],是全路径
RandomAcessFile类：文件数据的读写
写入数据：
File file = new File(“d:”+File.separator+”text.txt”);
RandomAcessFile acessfile = new RandomAcessFile(f,”rw”);读写方式打开文件。
Acessfile.writeBytes(“Hello”); Acessfile.writeInt(10);
Acessfile.close();
读取文件： .readByte() .readInt()
字节流、字符流的接本操作。
字节流输出主要使用OutputStream类完成，输入使用的是InputStream类，byte数组
字符流输出主要使用Writer类完成，输入主要是使用Reader类完成
操作步骤：（1）File打开文件 （2）通过字节流或字符流的子类指定输出位置
（3）读写操作（4）关闭输入/输出
OutputStream类是一个抽象类，若使用则必须首先实例化对象，若需要操作文件，使用FileOutputStream类，通过向上转型，为OutputStream实例化
常用方法：.close() 关闭输出流 .flush() 刷新缓冲区
.write(byte[] b)将byte数组写入数据流。
举例：File file = new File(“d:”+File.separator+”test.txt”);
OutputStream out = new FileOutputStream(file); //对象多态性，向上转型，进行实例化
Byte b[] = String str(“sdfasdfs”).getBytes();//只能输出Byte数组，字符串——》Byte数组
Out.write(b)
Out.close();
在后面追加新内容：通过FileOutputStream(File file, true)构造函数参数2，在末尾追加，通过添加\r\n实现换行的功能。
.read(byte[] b) 读取数据流：
Byte b [] = new byte[(int)File f.length]
InputStream Input.read(b);
字符流操作FileWriter FileReader
Writer out = new FileWriter(File file);
Out.write(“…”);与OutputStream无差别，更简单。之后out.flush()
通过FileWriter(File file,true)，构造函数参数2 设置。
字节流不用缓冲区，文件本省直接操作，字符流使用了缓冲区
内存操作流；ByteArrayinputStream 、ByteArrayOutputStream完成输入输出
ByteArrayinputStream: 方法：ByteArrayInputStream(byte[] buf),
ByteArrayInputStream(byte[] buf,int offset,intlength)
ByteArrayOutputStream：方法：ByteArrayOutputStream() write(int b)
String转为Byte[] 使用*.getBytes()
内存操作一般用于生成一些临时信息，
管道流：线程间通信
管道输出必须把输出流连在输入流上，PipedutputStream使用connect(PipedInputStream snk)
举例：两线程间数据传输：
Class Snd implements Runnable
{
复写run() { write();}
}
Class Receive implements Runnable
{
复写run() {read()};
}
Send sd = new Send(); Receive rcv = new Receive(); sd.connect(rcv);
System类对IO的支持
其中System.out.print()/System.out.println()调用的是PrintStream类的方法
BufferedReader类 用于从缓冲区读取内容，所有读取到数据放在缓冲区
常用方法：BufferedReader(Reader in),构造函数
String readLine()一次性将内容全部读出来
只能接收字符输入流的实例，须将字节流变为字符流。
String str = buf.readLine();//读取输入内容，可以是中文
第十三章 Java类集
类集:动态的对象数组,常用类集接口：
Collection：存放一组单值（每个元素都是一个对象）的最大接口，很少用
List：Collection子接口，对Collection扩充，内容允许重复。
Set: Collection子类，没有对Collection扩充，不允许存在重复内容。
SortedSet：对集合数据进行排序
Map：存放一对值的最大接口，Key Value形式。
Iterator：集合的输出接口，用于输出集合中 的内容，只能从前往后的单向输出。
Queue：队列接口，可实现队列操作。
Collection接口：public interface Collection
方法：
.add(E o)向集合插入对象
.addAll(Collection c)将一个集合内容插入进来。
.contains(Object o)判断是否某个对象
.isEmpty()是否为空
.remove(Object o)删除对象
.size()大小
List接口定义：public interface List
.add() .addAll() .get(int ..)返回指定位置的元素
.index()查找指定元素位置； .lastIndexOf()从后向前查找指定元素位置。
List<> subList(int from,int to)取出集合中的子集合 E set(int , E element)替换指定位置元素
List接口常用子类：
(1)ArrayList：继承AbstractList
List
allList.add(“dssfsd”); allList.add(0,”fsdfds”)
(2)Vector属于挽救的子类，同样继承AbstractList
LinkedList子类与Queue接口：链表操作类
LinkedList常用方法：*.addFirst(E o) 开头增加元素 *.addLast() 在结尾增加元素
*.removeFirst()删除第一个元素 *.removeLast() 删除最后一个
LinkedList
Link.add(“fasd”);…..
Set接口：不能加入重复的元素：public interface Set
主要方法与Collection一致。
Set常用子类：
（1）散列的存放：HashSet，里面不能存放重复元素，而且按照散列的存储方式。没有顺序。
Set
(2)有序存放：TreeSet
自定类如何排序？class Person implemnets Comparable
{复写toString(); 复写compareTo(Person person)}
String.compareTo(“sdafsd”);
SortedSet 接口：TreeSet实现了SortedSet接口，排序操作
SortedSet
Allset.add(“sd”);
集合的输出：
迭代器输出：iterator接口；碰到集合的输出操作，只要使用Interator接口。最标准做法
常用方法：*.hasNext()判断是否有下一个值，*.next*()取出当前值， *.remove()移除当前值
双向迭代输出：由前向后或是由后向前的双向输出，必须使用Iterator子接口——ListIterator，只能通过List 实例化
常用方法：*.hasNext()判断是否有下一个值 ； *.hasPrevious()取前一个值
Foreach除完成数组输出，同样支持集合。（不推荐用）
Map接口：以上均是单值，map可以操作多，每个元素均是
常用子类：
（1） HashMap无序存放，key不允许重复
（2） Hashtable 就操作，无序，key不允许重复 （就子类）
（3） TreeMap：排序的Map集合，按照key排序，不允许重复key
（4） WeakHashMap：某些内容不再使用时清除掉无用数据，gc回收
HashMap：定义class HashMap
方法：（1）增加：*.put(Object K,Object V) ,获取*.get(K)
Map
(2)判断是否存在：*.containsKey(K)
(3)输出全部key，Set
Iterator
TreeMap:排序子类（按K排序）
Map使用注意事项：
（1） 不能使用迭代器输出Map中所有内容，很少直接输出，仅作为查询使用
（2） 直接使用非系统类作为key，不可以，但可以做为Value，（例如：类）
Java开发实战经典(名师讲坛).doc
