2、Java面向对象

1. 继承的实现

Java通过extends实现类的继承。具体如下所示：

class Student extends Person
{

}

Java只允许多层继承，而不能多重继承，即一个子类只能继承一个父类。子类是不能直接访问父类中的私有成员的。子类对象在实例化之前必须首先调用父类中的构造方法后再调用子类自己的构造方法。

在子类中直接通过“super.方法()”形式即可访问父类中的相关方法。

2. final关键字

可以使用final关键字声明类、属性、方法，使用final声明的类不能有子类。使用final声明的方法不能被子类所覆写。使用final声明的变量即成为常量，常量不可以修改。

3. 抽象类的基本概念

抽象类的定义和使用如下：

• 包含一个抽象方法的类必须是抽象类。
• 抽象类和抽象方法都要使用abstract关键字声明。
• 抽象方法只需要声明而不需要实现。
• 抽象类必须被子继承，子类（如果不是抽象类）必须覆写抽象类中的全部抽象方法。

抽象类不能使用final关键字，不能使用private。

abstract class A
{
    public abstract void print(); //定义抽象方法
}
class B extends A
{
    public void print()
    {
        System.out.println("print");
    }
}

4. 接口的基本概念

接口是Java中最重要的概念之一，他可以被理解为一种特殊的类，是由全局常量和公共的抽象方法所组成。使用关键字implements实现接口实现。

interface 接口名称{
    全局变量
    抽象方法
}

在接口中的抽象方法必须定义为public访问权限，这是绝对不可改变的。下面是一个具体实现的例子。

interface A
{
    public String Author = "李兴华";
    public void print();
    public String getInfo();
}
abstract class B implements A
{
    public abstract void say();
}
class X extends B
{
    public void say()
    {

    }
    public String getInfo()
    {

    }
    public void print()
    {

    }
}

5. instanceof关键字

在Java中可以使用instanceof关键字判断一个对象到底是那个类的实例，如下所示：

对象 instanceof -> 返回 boolean 类型

具体用法如下所示：

class A
{
    public void fun1()
    {
        System.out.println("A->public void fun1(){}");
    }
    public void fun2()
    {
        this.fun1();
    }
};
class B extends A
{
    public void fun1()
    {
        System.out.println("B->public void fun1(){}");
    }
    public void fun3()
    {
        System.out.println("B->public void fun3(){}");
    }
};

publiv class InstanceofDemo
{
    public static void main(String[] args)
    {
        A a1 = new B();//通过向上转型实例化A类对象
        System.out.println("A a1=new B():" + (a1 instanceof A));
        System.out.println("A a1=new B():" + (a1 instanceof B));
        A a2 = new A();//通过A类的构造实例化本类对象
        System.out.println("A a1=new B():" + (a2 instanceof A));
        System.out.println("A a1=new B():" + (a2 instanceof B));
    }

}

6. 设计模式之Java

• 接口是Java解决多继承局限的一种手段。如下面的USB接口的实现：

interface USB
{
    public void start();
    public void stop();
}
class Computer
{
    public static void plugin(USB usb)
    {
        usb.start();
        System.out.println("--USB 设备工作--");
        usb.stop();
    }
};
class Flash implements USB
{
    public void start()
    {
        System.out.println("U盘开始工作。");
    }
    public void stop()
    {
        System.out.println("U盘停止工作。");
    }
};
class Print implements USB
{
    public void start()
    {
        System.out.println("打印机开始工作。");
    }
    public void stop()
    {
        System.out.println("打印机停止工作。");
    }
}

• 设计模式之工厂设计

程序在接口和子类之间加入了一个过渡端，通过此过渡端取得接口的实例化对象，一般都会称这个过渡端为工厂类。

//工厂设计模式
interface Fruit
{
    public void eat();
}
class Apple implements Fruit
{
    public void eat()
    {
        System.out.println("吃苹果");
    }
};
class Orange implements Fruit
{
    public void eat()
    {
        System.out.println("吃橙子");
    }
};
class Factory//工厂生产商品
{
    public static Fruit getInstance(String className)
    {
        Fruit f = null;
        if("apple".equals(className))
        {
            f = new Apple();
        }
        if("orange".equals(className))
        {
            f = new Orange();
        }
        return f;
    }
}

• 设计模式之代理模式

代理设计也是在Java开发中使用较多的一种设计模式，所谓的代理设计就是指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理，就好像在生活中经常使用的代理上网一样。代理操作如下：

interface Network{
  public void browse();
}
class Real implements Network{
  public void browse(){
    System.out.println("上网浏览信息");
  }
}
class Proxy implements Network{
   private Network network;
   public Proxy(Network network){
     this.network=network;
   }
   public void check(){
     System.out.println("检查用户是否合法");
   }
   public void browse(){
     this.check();
     this.network.browse();
   }
}
public class ProxyDemo{
   public static void main(String[] args){
     Network net=null;
     net=new Proxy(new Real());
     net.browse();
   }
}

• 设计模式之适配器设计

对于Java程序来说，如果一个类要实现一个接口，则必须要覆写此接口中的全部抽象方法，那么如果此时一个接口中定义的抽象方法过多，但是在子类中又用不到这么多抽象方法，则使用起来肯定很麻烦，所以此时就需要一个中间的过渡，但是此过渡类又不希望被直接使用，所以此过渡类定义成抽象类最合适，即一个接口首先被一个抽象类先实现，此抽象类通常称为适配器类，并在此抽象类中实现接口的若干方法。具体如下所示：

//适配器设计
interface Window{
  public void open();
  public void close();
  public activated();  //窗口活动
  public iconified();  //窗口最小化
  public deiconified();//窗口恢复大小
};
//定义抽象类实现接口，在此类中覆写方法，但是所有的方法体为空
abstract class WindowAdapter implements Window{
  public void activated(){}
  public void close(){}
  public void deiconified(){}
  public void iconified(){}
  public void open(){}
};
//子类直接继承WindowAdapter类，有选择地实现需要的方法
class WindowImpl extends WindowAdapter{
  public void open(){
   System.out.println("窗口打开");
  }
  public void close(){
   System.out.println("窗口关闭");
  }
};
public class AdapterDemo{
  public static void main(String[] args){
    Window win=new WindowImpl();
    win.open();
    win.close();
  }
}

• 抽象类与接口之间的关系

区别	抽象类	接口
定义	包含一个抽象方法的类	抽象方法和全局常量的集合
组成	构造方法、抽象方法、普遍方法、常量、变量	常量、抽象方法
使用	子类继承抽象类	子类实现接口
关系	抽象类可以实现多个接口	接口不能继承抽象类，但允许继承多个接口
设计模式	模板设计	工厂设计、代理设计
对象	都通过对象的多态产生实例化对象
局限	抽象类有单继承的局限	接口没有此局限
实际	作为一个模板	作为一个标准或表示一个能力
选择	如果抽象类和接口都可以使用，优先使用接口	避免单继承的局限
特殊	一个抽象类可以包含多个接口	一个接口中可以包含多个抽象类

在类的设计中，一定要明确记住一个原则，一个类不要去继承一个已经实现好的类，只能继承抽象类或者实现接口，如果接口和抽象类都可以使用，那么优先使用接口，避免单继承的局限。

7. Object类

在Java中所有的类都有一个公共的父类Object，一个类只要没有明显地继承一个类，则肯定是Object类的子类。实际上Object类中提供了很多的方法，这些方法经常被开发者使用。

public Object()
//构造，构造方法
public boolean equals(Object obj)
//普通、对象比较
public int hashCode()
//普通、取得Hash码
public String toString()
//普通，对象打印时调用

既然Object类是所有对象的父类，则所有的对象可以向Object进行转换，在这其中也包含了数组和接口类型，即一切的引用数据类型都可以使用Object进行接收，如下所示：

interface A{
  public String getInfo();
}
class B implements A{
  public String getInfo(){
    return "Hello World!!"
  }
}
public class ObjectDemo{
  public static void main(String[] args){
    A a=new B();
    Object obj=a;//对象向上转换
    A x=(A)obj; //对象向下转换
    System.out.println(x.getInfo());
  }
}

8. 包装类

基本数据类型和包装类的对应如下：

int->Integer
char->Character
short->Short
long->Long
float->Float
double->Double
boolean->Boolean
byte->Byte

包装类中的继承关系：

• Integer、Byte、Float、Double、Short、Long都属于Number类的子类，Number类本身提供了一系列的返回以上6种基本数据类型的操作。

• Character 属于Object的直接子类。

• Boolean属于Object的直接子类,Number类是一个抽象类，主要是将数字包装类中的内容变成基本数据类型，Number类的常用方法。

public byte byteValue();//以byte形式返回指定的数值
public abstract double doubleValue();//以double形式返回指定的数值
public abstract float floatValue();//以float形式返回指定的数值
public abstract int intValue();
public abstract long longValue();
public abstract short shortValue();

下面是包装类的应用：

//装箱与拆箱
Integer i=new Integer(x);
int temp=i.intValue();
//包装类的应用
//将一个全由数字组成的字符串变为一个int或者float类型的数据
//Integer类-字符转int型
public static int parseInt(String s) throws NumberFormatException
//Float类-字符转float型
public static float parseFloat(String s)throws NumberFormatException