第11章（下）--面向对象编程（高级特性）

1.  抽象类

 

当父类的一些方法不能确定时,可以用abstract关键字来修饰该方法，这个方法就是抽象方法,用abstract 来修饰该类就是抽象类。

      抽象类的介绍

 

1)      用abstract 关键字来修饰一个类时,这个类就叫抽象类
访问修饰符 abstract 类名{
}

2)      用abstract 关键字来修饰一个方法时,这个方法就是抽象方法
访问修饰符 abstract 返回类型 方法名(参数列表);

 

3)      抽象类的价值更多是在于设计，是设计者设计好后，让子类继承并实现抽象类(即：实现抽象类的抽象方法)

 

4)      抽象方法在编程中用的不是很多,但是在公司笔试时,却是考官比较爱问的知识点

   抽象类使用的注意事项和细节讨论

 

1)      抽象类不能被实例化  [举例]

2)      抽象类不一定要包含abstract方法。也就是说,抽象类可以没有abstract方法 [举例]

3)      一旦类包含了abstract方法,则这个类必须声明为abstract [说明]

4)      abstract 只能修饰类和方法，不能修饰属性和其它的。[说明]

5)      抽象类可以有任意成员【因为抽象类还是类】，比如：非抽象方法、构造器、静态属性等等 [举例]

6)      抽象方法不能有主体，即不能实现.如图所示

7)      如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类。[举例 A类,B类,C类]

8)      抽象方法不能使用private、final 和 static来修饰，因为这些关键字都是和重写相违背的。说明: static关键字是不和重写相关，static方法不能重写

 

• 和前面一样，多态在抽象类上也体现在

多态数组【存放不同的子类对象, Dog和Cat】

多态参数【接收不同的子类对象】

public class AbstractPolyDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        Animal03 animals[] = new Animal03[2];
        animals[0] = new Cat03();
        animals[1] = new Dog03();
        
        //抽象类体现出多态数组
        for (int i = 0; i < animals.length; i++) {
            animals[i].eat();
            show(animals[i]);
        }

    }
    
    //多态参数
    public static void show(Animal03 animal) {
        if (animal instanceof Cat03) {
            Cat03 cat = (Cat03)animal;
            cat.catchMouse();
        } else if (animal instanceof Dog03) {
            Dog03 dog = (Dog03)animal;
            dog.watchDoor();
        }
    }

}

abstract class Animal03 {
    
    abstract public void eat();
}

class Cat03 extends Animal03 {

    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("小猫喜欢吃<・)))><<");
    }
    
    public void catchMouse() {
        System.out.println("小猫抓老鼠");
    }
    
}

class Dog03 extends Animal03 {

    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("小狗喜欢吃骨头~~");
    }
    
    public void watchDoor() {
        System.out.println("小狗看门~~");
    }
    

 

        抽象类最佳实践-模板设计模式

1.1.1       基本介绍

 

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。

当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。

编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式。

   

     最佳实践

 

设计一个抽象类(Template)，能完成如下功能:

1)      编写方法caleTime() ,可以计算某段代码的耗时时间

2)      编写抽象方法code()

3)      编写一个子类Sub,继承抽象类Template，并实现code方法。

4)      编写一个测试类TestTemplate,看看是否好用。

 

public class AbstractTemplateDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Sub sub = new Sub();
        sub.caleTime();
        
        Sub2 sub2 = new Sub2();
        sub2.caleTime();

    }

}

// 通过抽象类开发要给 模板设计模式

abstract class Template {

    abstract public void code(); // code不确定.
    // 统计code() 方法执行时间

    public void caleTime() {
        // 1先得到当前的时间(毫秒)
        long nowTime = System.currentTimeMillis();
        code();
        // 2得到执行后的时间
        long endTime = System.currentTimeMillis();
        System.out.println("执行代码时间为=" + (endTime - nowTime));
    }
}

class Sub extends Template { // 张三

    @Override
    public void code() {
        // TODO Auto-generated method stub
        // 测试 hello, 拼接 10000次
        String str = "hello";
        for (int i = 0; i < 20000; i++) {
            str += "jack" + i;
        }

    }

}

class Sub2 extends Template {// 李四

    @Override
    public void code() {
        // TODO Auto-generated method stub
        // 测试 hello, 拼接 10000次
        StringBuilder str = new StringBuilder("hello");
        for (int i = 0; i < 20000; i++) {
            str.append("jack" + i);
        }

    }

}

  标准 服务 产品 项目

 

2.接口

接口快速入门

public class InterfaceDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Computer computer = new Computer();
        Phone phone = new Phone();
        Camera camera = new Camera();
        
        computer.work(phone); //这里因为Phone已经实现了UsbInterface
        computer.work(camera);//这里因为Camera已经实现了UsbInterface

    }

}


class Computer {
    public void work(UsbInterface usbInterace) {
        //...
        usbInterace.start();
        usbInterace.start();
    }
}

//定义给接口，要求各个类去实现
interface UsbInterface {
    //定一些规范, 规范可以简单的理解就是方法（没有实现的方法）
    public void start();
    public void stop();
}

class Camera implements UsbInterface {

    @Override
    public void start() {
        // TODO Auto-generated method stub
        System.out.println("相机开始工作~~");
    }

    @Override
    public void stop() {
        // TODO Auto-generated method stub
        System.out.println("相机结束工作~~");
        
    }
    
}

class Phone implements UsbInterface {

    @Override
    public void start() {
        // TODO Auto-generated method stub
        System.out.println("手机开始工作~~");
        
    }

接口就是给出一些没有实现的方法,封装到一起,到某个类要使用的时候,在根据具体情况把这些方法写出来。

• 语法:

interface 接口名{

   //属性

   //抽象方法

}

class 类名 implements 接口{

      自己属性;

      自己方法;

      实现的接口的抽象方法

}

• 小结:接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都

没有方法体【jdk7.0以前】。接口体现了程序设计的多态和高内聚低偶合的设计思想。高内聚坏了不会影响到别人，低耦合两个模块耦合性很低

• 特别说明：Jdk1.8后接口类可以有静态方法，默认方法，也就是说接口中可以有方法的

具体实现, 这个放在jdk8新特性说明

接口应用场景

 

public class InterfaceJdbcTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        JdbcInterface jdbc = new MySqlDB();
        jdbc.connect();
        System.out.println(jdbc.operate());
        jdbc.close();
        
        jdbc = new DB2();
        
        jdbc.connect();
        System.out.println(jdbc.operate());
        jdbc.close();

    }

}


interface JdbcInterface {
    public void connect();
    public String operate();
    public void close();
}

class MySqlDB implements JdbcInterface {

    @Override
    public void connect() {
        // TODO Auto-generated method stub
        System.out.println("连接mysql");
    }

    @Override
    public String operate() {
        // TODO Auto-generated method stub
        return "操作mysql";
    }

    @Override
    public void close() {
        // TODO Auto-generated method stub
        System.out.println("关闭mysql");
    }
    
}

class DB2 implements JdbcInterface {

    @Override
    public void connect() {
        // TODO Auto-generated method stub
        System.out.println("连接DB2");
        
    }

    @Override
    public String operate() {
        // TODO Auto-generated method stub
        return "操作db2成功";
    }

    @Override
    public void close() {
        // TODO Auto-generated method stub
        System.out.println("关闭db2");
    }
    
}

     注意事项和细节

 

1)      接口不能被实例化

2)      接口中所有的方法都public或者default 的抽象方法,图示:

3)      一个普通类实现接口,就必须将该接口的所有方法都实现。

4)      抽象类实现接口，可以不用实现接口的方法。

5)      一个类可以实现多个接口 [举例]

6)      接口中的属性,只能是常量，而且是 public static final 修饰符。比如：
int a=1; 实际上是 public static final int a=1; (必须初始化)

7)      接口中常量的访问形式: 接口名.变量名

8)      一个接口不能继承其它的类,但是可以继承多个别的接口 [举例]

9)      接口的修饰符 只能是 public 和默认，这点和类的修饰符是一样的。

public class ExtendsVSImplement {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        LittleMonkey littleMonkey = new LittleMonkey("悟空", (short)10);
        littleMonkey.climbing();
        littleMonkey.fly();
        littleMonkey.swim();
        
        Monkey m = littleMonkey;
        m.climbing();
        IBirdable a = littleMonkey;
        a.fly();
        IFishable b = littleMonkey;
        b.swim();
        
        

    }

}

//猴子类
class Monkey {
    private String name;
    private short age;
    
    
    
    public Monkey(String name, short age) {
        super();
        this.name = name;
        this.age = age;
    }

    public void climbing() {
        System.out.println(name + " 能爬树~~");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public short getAge() {
        return age;
    }

    public void setAge(short age) {
        this.age = age;
    }
    
    
}

interface IBirdable {
    public void fly();
}
interface IFishable {
    public void swim();
}

class LittleMonkey extends Monkey implements IBirdable,IFishable {
    
    
    public LittleMonkey(String name, short age) {
        // TODO Auto-generated constructor stub
        super(name, age);
    }
    
    public void fly() {
        System.out.println(getName() + " 通过学习会飞翔~~");
    }
    public void swim() {
        System.out.println(getName() + " 通过学习会游泳~~");
    }
}

 

3.接口和继承比较 

 

实现接口可以看作是对继承的一种补充

java的继承是单继承,也就是一个类最多只能有一个父类,这种单继承的机制可保证类的

纯洁性,比c++中的多继承机制简洁。但是不可否认,对子类功能的扩展有一定影响.所以

我们认为: 实现接口可以看作是对 继承的一种补充

• 接口和继承解决的问题不同

 

继承的价值主要在于：解决代码的复用性和可维护性。

接口的价值主要在于：设计，设计好各种规范(方法)，让其它类去实现这些方法。

 

 

• 接口比继承更加灵活

 

接口比继承更加灵活，继承是满足 is - a的关系，而接口只需满足 like - a的关系。

 

• 接口在一定程度上实现代码解耦

 

 接口练习：

 

4.内部类

1.1.1       基本介绍

 

一个类的内部又完整的嵌套了另一个完整的类结构。被嵌套的类称为内部类(inner class)，嵌套其他类的类称为外部类(outer class)。是我们类的第五大成员

类的五大成员是哪些?[属性，方法，构造器，代码块，内部类]】，内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系。

1.1.1       基本语法

 

class Outer{ //外部类
               class Inner{ //内部类

              }
       }
       class Other{ //外部其他类
       }

1.1.1       内部类的分类

 

 

• 定义在外部类的成员位置上：

1) 成员内部类（没用static修饰）

2) 静态内部类（使用static修饰）

 

 

• 定义在外部类局部位置上（比如方法内）：

1) 局部内部类（有类名）

2) 匿名内部类（没有类名）

 

1.1.2       成员内部类的使用

 

说明：成员内部类是定义在外部类的成员位置，并且没有static修饰。

1) 可以直接访问外部类的所有成员，包含私有的

2) 可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员.

3) 作用域
   和外部类的其他成员一样，为整个类体, 比如前面案例，在外部类的成员方法中创建成员内部类对象，再调用方法

4) 成员内部类---访问---->外部类(比如：属性)  [访问方式：直接访问] (说明)

5) 成员外部类---访问------>内部类 (说明)
           访问方式：创建对象，再访问

6) 外部其他类---访问---->成员内部类

 

7) 如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.this.成员）去访问

 

 

1.1.1       静态内部类的使用

 

1) 说明：静态内部类是定义在外部类的成员位置，并且有static修饰

2) 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员

3) 可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员。

4) 作用域
       同其他的成员，为整个类体

5) 静态内部类---访问---->外部类(比如：静态属性)  [访问方式：直接访问所有静态成员]

6) 外部类---访问------>静态内部类 访问方式：创建对象，再访问

7) 外部其他类---访问----->静态内部类

8) 如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.成员）去访问