本文主要是介绍一下java面向对象编程方面的知识，涉及的内容可能有点多，所以可能会感觉比较笼统，详细请参见《Java编程思想》里面比较具体点。
1.面向对象
和遵循设计原则和设计模式，
目标都是为了消除程序中的重复代码
重复代码一般是放在父类中的
Dog dog=new Dog()
左边是创建一个Dog的引用，右边是创建Dog的一个对象，这个过程是对象实例化也就是把对象的赋值给引用（相当于创建了一个结构体变量并进行了初始化）
创建对象就相当于给结构体进行初始化，创建后除了分配了内存，构造函数被调用，其中的方法也可以被调用了(除了加了static的方法，因为加了是静态的，就不需要创建也能调用了)，相当于结构体里面的函数指针对初始化了，可以被使用了
2.super和this
简单理解，super是指向父类的，this是指向当前类（对象）的，
(super.xx是调用父类的方法，this.xx是调用子类当前类的方法)
3. 抽象类和抽象函数
抽象函数里面是没有函数体的，定义抽象函数必须是在抽象类里面，
但是抽象函数可以给子类使用进行复写（关键字@ overwrite）
（子类对父类中的函数进行复写），
创建一个对象就分配了内存，同时就会自动调用了构造函数，当子类创建对象时，父类必须也是创建了对象的（为了保证子类创建对象父类也创建了对象调用了构造函数，子类的构造函数中加一个super()就会去调用父类的构造函数，对父类进行了对象创建），
所以虽然抽象类是不可以被创建对象的，但是抽象类的子类创建对象后，抽象类就会被创建了抽象函数，同时父类的构造函数也就会被调用（等于自动在子类的构造函数中加了super()）
4.包（软件包）
就是相同名字的类放在不同的文件夹，一个包里就是一个文件夹里有类
在类的前面加一行打包关键字，表示当前的类放在一个包里
执行的时候要注意，带上包名，即包名.类名
包名都要小写，
package org.mars 就会生成一级级的目录，也就是先org然后里面是mars目录然后里面才是类
5.接口(类似C中的钩子函数)---很重要
特殊的类，特殊的抽象类，里面全是抽象函数，使用interface定义，省略了class，
同时抽象函数都是Public权限(即使写了其他的也是public)的
通过继承接口(类)，来复写抽象函数，然后生成子类的对象
class usbphone implements USB{
}
使用implements不再是extends，这里继承接口(特殊的继承)，也叫实现接口(要复写抽象函数)，因为接口里面都是抽象的并没有具体
例子:
interface Usb{
public void read();
public void write();
}
定义子类实现：
class Phone implements Usb{
public void read(){
system.out.println();
}
public void write(){
system.out.println();
}
}
使用方法
class Test{
public static main(String args[]){
Phone phone=new Phone();
Usb usb =phone;//向上转型：把子类的对象赋值给父类的引用
usb.read();//这样父类对象就实例化了，父类中的函数就可以被调用了
}
}
向上转型：把子类的对象赋值给父类的引用
一个类只能有一个父类，单继承
但是一个类可以实现多个接口,一个接口可以继承多个接口
一个类可以实现多个接口:
interface WiFi{
void open();
void read();
}
class Phone implements Usb,WiFi{
public void read(){
system.out.println();
}
public void write(){
system.out.println();
}
public void open(){
system.out.println();
}
public void write(){
system.out.println();
}
}
class Test{
public static main(String args[]){
Phone phone=new Phone();
Usb usb =phone;//向上转型：把子类的对象赋值给父类的引用
usb.read();//这样父类对象就实例化了，父类中的函数就可以被调用了
WiFi wifi =phone;//向上转型：把子类的对象赋值给父类的引用
wifi.close();//这样父类对象就实例化了，父类中的函数就可以被调用了
}
}
一个接口可以继承多个接口：这里是继承不是实现，因为没有复写
interface A{
void funa();
}
interface B{
void funb();
}
interface C extends A,B{//这样C中就包含A,B中的方法，当实现C的时候就要复写A,B中的，也就是三个方法都要复写
void func();
}
6.工厂设计模式：
Class Test｛
public static main(String args[]){
Printer printer=null;//类来创建对象(一个引用 左边)，对象等于null就是还未实例化，对象等于new出来空间的地址或者等于一个地址就是对象的实例化（获得实例化对象）
int flag=1;
if(flag==0)
printer=new HpPrint();//向上转型
else if(flag==1)
printer=new CanPrint();
printer.open();//由于向上转型了，父类对象实例化了，所以父类中的方法可以调用了
printer.print("ets");
printer.close();
}
｝
但是这个程序还有问题，当不断添加打印机就要不断对该打印机类型的对象实例化，并增加if else 如果很多个增加就麻烦了，代码很多。。。
一般对于重复代码，就是封装到函数里，然后来调用，可以通过参数来获得想要的，好处就是不用每次出现这段代码的地方都修改，而是只是修改函数里面的就可以了：(这就是所谓的工厂设计模式，需要的时候给参数到工厂，然后工厂根据你给的参数生产出你要的)
还有好处，对于使用者不知道内部有哪些子类，也不用关心内部有那些子类，对于开发来说就可以对于子类随时可以删除修改一下工厂就好了，外部提供的地方不用修改
Class Printfactory｛
public static Print getPrinter(int flag){
Printer printer=null;//类来创建对象(一个引用 左边)，对象等于null就是还未实例化，对象等于new出来空间的地址或者等于一个地址就是对象的实例化（获得实例化对象）
int flag=1;
if(flag==0)
printer=new HpPrint();//向上转型
else if(flag==1)
printer=new CanPrint();
return printer;
}
｝
Class Test｛
public static main(String args[]){
int flag=1;
Printer priner=Printfactory.getPrinter(flag);
printer.open();//由于向上转型了，父类对象实例化了，所以父类中的方法可以调用了
printer.print("ets");
printer.close();
}
｝
7.异常 (有点类似中断)
JAVA中所有东西都是对象，同理异常也是一个对象
产生事件，就会生成一个异常对象
有可能出现异常的代码放在TRY里面，处理异常代码放在catch，finally里面主要是放一些释放资源的代码
try里面出现异常就会执行catch里面的代码，没出现异常就不会执行catch里面的代码，finally里面的代码不管出现不出现都会执行
throw ,throws抛出异常
class User{
private int age;
public void setAge(int age){
if(age<0)
{
RuntimeException e=new RuntimeException("年龄不能为负数");//创建一个异常对象（属于unChecked Exception,不需要用try catch处理，如果是Exception和它的子类除了RuntimeException,用这些checkedException就需要用try catch处理，如果还不想使用try catch，就加声明也就是throws，让谁调用谁处理）
throw e;//抛出这个异常对象，当JAVA虚拟机收到这个异常对象，会终止这个程序运行，并打印
}
this.age=age;
}
}
class User{
private int age;
public void setAge(int age)throws Exception{//checkException还不想使用try catch，就加声明也就是throws，让谁调用谁处理）
if(age<0)
{
Exception e=new Exception("年龄不能为负数");//创建一个异常对象
throw e;//抛出这个异常对象，当JAVA虚拟机收到这个异常对象，会终止这个程序运行，并打印
}
this.age=age;
}
}
调用的地方处理：
class Test{
public static main(String args[]){
User user=new User();
try{
user.setAge(-20);
}
catch(Exception e){
system.out.println(e);
}
}
}
8.JAVA当中的IO
InputStrem OutputStream是所以字节流的父类，都是抽象类
子类有
FileInputStream FileOutputStream
例如：
OutputStream os = socket.getOutputStream();
os.write(msg.getBytes());
InputStream mmInStream = null;
mmInStream = socket.getInputStream();
if( (bytes = mmInStream.read(buffer)) > 0 )
{
byte[] buf_data = new byte[bytes];
for(int i=0; i<bytes; i++)
{
buf_data[i] = buffer[i];
}
String s = new String(buf_data);
ForView.setText(s);
}
mmInStream.close();
9. 内部类和匿名内部类
内部类：
定义在一个类的里面：
假设B定义在A里面：
A a=new A();
内部类则是:
A.B b=new A().new B();
this默认是当前类的成员，如果使用外部类就要A.this.i这样来
匿名内部类:
是内部类，但是没有名字
class B{
public void fun(A a){
System.out.println();
a.doSomething();
}
}
class Test{
public static main(String args[]){
B.b=new B();
b.fun(new A(){//这里就是一个类，匿名内部类，相当于这里定义一个实现A接口的子类，这样A就可以NEW出来了
public void dosomething(){
System.out.println();
}
})
}
}
10.线程:
class FirstTread extends Thread{
public void run(){
system.out.println();
}
}
class Test{
public static main(String args[]){
FirstTread firstthread=new FirstTread();//创建线程
firstthread.start()//线程就绪运行
}
}
第二种方法：(由于继承只能使用一次，所以能不用就不用，所以第二种用的多些)
class Runnabletmp implements Runnable{
public void run(){
}
}
class Test{
public static main(String args[]){
Runnable runable=new Runnable();//生成一个实现接口的对象
Tread t=new Thread(runnable);//并将对象传进去（相当于结构体变量传进去）
t.start();
}
}
控制函数：
Tread.sleep() Thread.yield()
getPriority() setPriority();
线程最大优先级10最小1，可以使用Thread.里面提供的静态常量当参数进行设置