java之面向对象20160818

本文主要是介绍一下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.里面提供的静态常量当参数进行设置