java之面向对象20160818

时间 2019-11-13

标签 java 面向对象栏目 Java 繁體版

原文原文链接

本文主要是介绍一下java面向对象编程方面的知识，涉及的内容可能有点多，因此可能会感受比较笼统，详细请参见《Java编程思想》里面比较具体点。java

1.面向对象编程

和遵循设计原则和设计模式，设计模式

目标都是为了消除程序中的重复代码socket

重复代码通常是放在父类中的函数

Dog dog=new Dog()this

左边是建立一个Dog的引用，右边是建立Dog的一个对象，这个过程是对象实例化也就是把对象的赋值给引用（至关于建立了一个结构体变量并进行了初始化）spa

建立对象就至关于给结构体进行初始化，建立后除了分配了内存，构造函数被调用，其中的方法也能够被调用了(除了加了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){

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.里面提供的静态常量当参数进行设置