java之面向对象20160818,javaclass先后次序

父类A非静态代码块-&gt,子类B非静态代码块-&gt,详细请参见《Java编程思想》里面比较具体点,重复代码一般是放在父类中的

关于Java中一个Class执行先后次序的问题,javaclass先后次序

首先贴出代码,如下:

public class Test {
  public static void main(String[] args) {
    A a=new B();
    a.a();
  }
}

class A{
  public A(){
    System.out.println(“I’am A”);
龙8游戏,  }
  static{
    System.out.println(“AAAAA”);
  }
  {
    System.out.println(“111”);
  }
  public void a(){
    System.out.println(“aaa”);
  }
}

class B extends A{
  public B(){
    System.out.println(“I’am B”);
  }
  static{
    System.out.println(“BBBBB”);
  }
  {
    System.out.println(“222”);
  }
  public void a(){
    System.out.println(“bbb”);
  }
}

这段代码的执行结果如下:

AAAAA
BBBBB
111
I’am A
222
I’am B
bbb

这是一个很基础但是却非常容易错误的一个知识点,因为在Java类中代码有如下的执行顺序:

父类A静态代码块->子类B静态代码块->父类A非静态代码块->父类A构造函数->子类B非静态代码块->子类B构造函数

至于a.a()这个方法的输出结果,变量a是一个a()方法被子类覆盖的Class
A对象,变量a的普通方法(非静态方法),在编译时是与父类一致的,运行时却与子类一致,发生了复写,输出:bbb;

若变量a的a()方法是静态的,则是先于对象建立之前就存在了,无法被后出现的B类对象所复写的,所以没发生复写,依旧输出:aaa

首先贴出代码,如下: public class Test { public static void
main(String[] args) { A a=new B();…

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

1.面向对象

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

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

 

重复代码一般是放在父类中的

 

Dog dog=new Dog()

左边是创建一个Dog的引用,右边是创建Dog的一个对象,这个过程是对象实例化也就是把对象的赋值给引用(相当于创建了一个结构体变量并进行了初始化)

 

创建对象就相当于给结构体进行初始化,创建后除了分配了内存,构造函数被调用,其中的方法也可以被调用了(除了加了static的方法,因为加了是静态的,就不需要创建也能调用了),相当于结构体里面的函数指针对初始化了,可以被使用了

2.super和this

简单理解,super是指向父类的,this是指向当前类(对象)的,

(super.xx是调用父类的方法,this.xx是调用子类当前类的方法)

  1. 抽象类和抽象函数

抽象函数里面是没有函数体的,定义抽象函数必须是在抽象类里面,

但是抽象函数可以给子类使用进行复写(关键字@ 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();

 

  1. 内部类和匿名内部类

内部类:

定义在一个类的里面:

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