程序博客网 > 淘宝时尚初秋长袖睡衣

Java继承

来源：互联网 发布：淘宝时尚初秋长袖睡衣 编辑：程序博客网 时间：2024/05/16 06:50

3.7 数组工具类

     示例：
  1. public class ArrayTool{
  2.        //该类中的方法都是静态的，所以该类是不需要创造对象的
  3.        //为了保证不让他人创建该类对象，可以将构造函数私有化
  4.        private ArrayTool(){}

  6.        //获取整型数组的最大值
  7.        public static int getMax(int[] arr){
  8.              int maxIndex = 0;
  9.              for(int x = 1; x < arr.length; x++){
  10.                    if(arr[x] > arr[maxIndex])
  11.                         maxIndex = x;
  12.              }
  13.              return arr[maxIndex];
  14.       }

  16.        //对数组进行选择排序
  17.        public static void selectSort(int[] arr){
  18.              for(int x = 0; x <arr.length -1; x++){
  19.                    for(int y = x + 1; y < arr.length; y++){
  20.                          if(arr[x] > arr[y])
  21.                                swap(arr,x,y);
  22.                    }
  23.              }
  24.        }

  26.        //用于给数组进行元素的位置置换。
  27.        private static void swap(int[] arr, int a,int b){
  28.              int temp = arr[a];
  29.             arr[a] = arr[b];
  30.             arr[b] = temp;
  31.        }

  33.        //获取指定的元素在指定数组中的索引
  34.        public static int getIndex(int[] arr, int key){
  35.              for(int x = 0; x < arr.length; x++){
  36.                    if(arr[x] == key)
  37.                          return x;
  38.             }
  39.              return -1;
  40.       }

  42.        //将int 数组转换成字符串，格式是：[e1,e2,...]
  43.        public static String arrayToString(int[] arr){
  44.             String str = "[";

  46.              for(int x = 0; x < arr.length; x++){
  47.                    if(x != arr.length - 1)
  48.                         str = str + arr[x] + ",";
  49.                    else
  50.                         str = str + arr[x] + "]";
  51.             }
  52.              return str;
  53.       }
  54. }

  56. class ArrayToolDemo{
  57.       //保证程序的独立运行
  58.        public static void main(String[] args){
  59.             int[] arr = {4,8,2,9,7,72,6};

  61.             int max = ArrayTool.getMax(arr);
  62.             System.out.println("max = " + max);
  63.             int index = ArrayTool.getIndex(arr,10);
  64.             System.out.println("index = " + index);
  65.       }
  66. }

   运行结果：


3.10 文档注释

    示例：
  1. /**
  2. * 建立一个用于操作数组的工具类，其中包含着常见的对数组操作的函数，如：最值，排序等。
  3. * @author 张三
  4. * @version v1.0
  5. */
  6. public class ArrayTool{
  7.        private ArrayTool(){}

  9.        /**
  10.        * 获取整型数组的最大值
  11.        * @param arr 接收一个元素为int 类型的数组
  12.        * @Return 该数组的最大的元素值
  13.        */
  14.        public static int getMax(int[] arr){
  15.              int maxIndex = 0;
  16.              for(int x = 1; x < arr.length; x++){
  17.                    if(arr[x] > arr[maxIndex])
  18.                         maxIndex = x;
  19.             }
  20.              return arr[maxIndex];
  21.       }

  23.       /**
  24.        * 对数组进行选择排序
  25.        * @param arr 接收一个元素为int 的数组
  26.        */
  27.        public static void selectSort(int[] arr){
  28.              for(int x = 0; x <arr.length -1; x++){
  29.                    for(int y = x + 1; y < arr.length; y++){
  30.                          if(arr[x] > arr[y])
  31.                                swap(arr,x,y);
  32.                   }
  33.             }
  34.       }

  36.        //用于给数组进行元素的位置置换。
  37.        private static void swap(int[] arr, int a,int b){
  38.             int temp = arr[a];
  39.             arr[a] = arr[b];
  40.             arr[b] = temp;
  41.       }

  43.        /**
  44.        * 获取指定的元素在指定数组中的索引
  45.        * @param arr 接收一个元素为int 类型的数组
  46.        * @param key 要找的元素
  47.        * @return 返回该元素第一次出现的位置，如果不存在则返回 -1
  48.        */
  49.        public static int getIndex(int[] arr, int key){
  50.              for(int x = 0; x < arr.length; x++){
  51.                    if(arr[x] == key)
  52.                          return x;
  53.              }
  54.              return -1;
  55.        }

  57.        /**
  58.        * 将int数组转换成字符串，格式是：[e1,e2,...]
  59.        * @param arr 接收一个元素为int类型的数组
  60.        * @return 返回该数组的字符串表现形式           
  61.        */
  62.        public static String arrayToString(int[] arr){
  63.             String str = "[";

  65.              for(int x = 0; x < arr.length; x++){
  66.                    if(x != arr.length - 1)
  67.                         str = str + arr[x] + ",";
  68.                    else
  69.                         str = str + arr[x] + "]";
  70.             }
  71.              return str;
  72.       }
  73. }

   运行结果：


 

 

    P.S.
    1、如果想把一个类进行文档化，该类必须是public的。
    2、私有的方法在文档中不会体现，例如ArrayTool类中的swap方法。

3.11 单例设计模式

    设计模式：对问题行之有效的解决方式，其实，它是一种思想。

    单例设计模式解决的问题：就是可以保证一个类在内存中的对象唯一性。
    比如多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。

    如何保证对象唯一性呢？
    1、不允许其他程序用new创建该类对象。
    2、在该类创建一个本类实例。
    3、对外提供一个方法让其他程序可以获取该对象。

    步骤：
    1、私有化该类构造函数。
    2、通过new在本类中创建一个本类对象。
    3、定义一个公有的方法，将创建的对象返回。

    示例（饿汉式）：
  1. class Single{
  2.        //类已加载，对象就已经存在了
  3.        private static Single s = new Single();

  5.        private Single(){}

  7.        public static Single getInstance(){
  8.              return s ;
  9.       }
  10. }

  12. class SingleDemo{
  13.        public static void main(String[] args){
  14.             Single s1 = Single.getInstance();
  15.             Single s2 = Single. getInstance();
  16.             System.out.println(s1 == s2);
  17.       }
  18. }

    运行结果：


    P.S.
    之所以不用Single.s;的方式获取Single对象，而采用getInstance获取是因为在getInstance方法中我们可以做一些判断来决定是否返回Single的对象，也就是实现了对单例对象的可控。所以，给Single的构造方法加上了private限制，禁止使用者直接采用Single.s;的方式获取。

    示例（懒汉式）：
  1. class Single{
  2.        //类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象
  3.        //延迟加载形式
  4.        private static Single s = null;

  6.        private Single(){}

  8.        public static Single getInstance(){
  9.              if(s == null)
  10.                    s = new Single();
  11.              return s ;
  12.       }
  13. }

  15. class SingleDemo{
  16.        public static void main(String[] args){
  17.             Single s1 = Single. getInstance();
  18.             Single s2 = Single. getInstance();
  19.             System.out.println(s1 == s2);
  20.       }
  21. }

    运行结果：


4、继承

4.1 继承的描述

    通过 extends 关键字让类与类之间产生继承关系。
    多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。多个类可以称为子类，单独这个类称为父类或者超类。

    P.S.
    1、子类可以直接访问父类中的非私有的属性和行为。
    2、子类无法继承父类中私有的内容。
    3、父类怎么来的？共性不断向上抽取而来的。

    示例：
  1. class Person{
  2.       String name;
  3.       int age ;
  4. }

  6. class Student extends Person{
  7.        void study(){
  8.             System.out.println("student study..." + age);
  9.       }
  10. }

  12. class Worker extends Person{
  13.        void work(){
  14.             System.out.println("worker work..." + age);
  15.       }
  16. }

  18. class ExtendDemo{
  19.        public static void main(String[] args){
  20.             Student s = new Student();
  21.             s. name = "zhangsan" ;
  22.             s. age = 20;
  23.             s.study();

  25.             Worker w = new Worker();
  26.             w. name = "lisi" ;
  27.             w. age = 30;
  28.             w.work();
  29.       }
  30. }

    运行结果：


    好处：
    继承的出现提高了代码的复用性。
    继承的出现让类与类之间产生了关系，提供了多态的前提。

4.2 继承的特点

    Java只支持单继承，不支持多继承。
    一个类只能有一个父类，不可以有多个父类。

    原因：
    因为多继承容易出现问题。两个父类中有相同的方法，子类到底要执行哪一个是不确定的。

    示例：
  1. class A{
  2.        void show(){
  3.             System.out.println("a" );
  4.       }
  5. }

  7. class B{
  8.        void show(){
  9.             System.out.println("b" );
  10.       }
  11. }

  13. class C extends B,A{

  15. }


    那么创建类C的对象，调用show方法就不知道调用类A中的show方法还是类B中的show方法。所以java不支持多继承，但将这种机制换了另一个安全的方式来体现，也就是多实现（后面会详细说明）。

    Java支持多层继承(继承体系)：
    C继承B，B继承A，就会出现继承体系。
    多层继承出现的继承体系中，通常看父类中的功能，了解该体系的基本功能，建立子类对象，即可使用该体系功能。

    定义继承需要注意：
    不要仅为了获取其他类中某个功能而去继承，类与类之间要有所属( "is a")关系。

4.3 super关键字&函数覆盖

    在子父类中，成员的特点体现：

    1. 成员变量
        this和super的用法很相似。
        this代表本类对象的引用。
        super代表父类的内存空间的标识。

        当本类的成员和局部变量同名用this区分。
        当子父类中的成员变量同名用super区分父类。

    示例：
  1. class Fu{
  2.        private int num = 4;

  4.        public int getNum(){
  5.              return num ;
  6.       }
  7. }

  9. class Zi extends Fu{
  10.        private int num = 5;
  11.     
  12.        void show(){
  13.             System.out.println(this.num + "..." + super.getNum());
  14.       }
  15. }

  17. class ExtendDemo{
  18.        public static void main(String[] args){
  19.             Zi z = new Zi();
  20.             z.show();
  21.       }
  22. }

   运行结果：


    2. 成员函数
        当子父类中出现成员函数一模一样的情况，会运行子类的函数。
        这种现象，称为覆盖操作，这是函数在子父类中的特性。
        在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

    函数两个特性：
    1. 重载，同一个类中。
    2. 覆盖，子类中，覆盖也称为重写，覆写，override。

    示例：
  1. class Fu{
  2.        public void show(){
  3.             System.out.println("fu show run" );
  4.       }
  5. }

  7. class Zi extends Fu{
  8.        public void show(){
  9.             System.out.println("zi show run" );
  10.       }
  11. }

  13. class ExtendDemo{
  14.        public static void main(String[] args){
  15.             Zi z = new Zi();
  16.             z.show();
  17.       }
  18. }

    运行结果：


    什么时候使用覆盖操作？
    当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

    示例：
  1. class Phone{
  2.        void call(){}
  3.        void show(){
  4.             System.out.println("number" );
  5.       }
  6. }

  8. class NewPhone extends Phone{
  9.        void show(){
  10.             System.out.println("name" );
  11.             System.out.println("pic" );
  12.             super.show();
  13.       }
  14. }

  16. class ExtendDemo{
  17.        public static void main(String[] args){
  18.             NewPhone p = new NewPhone();
  19.             p.show();
  20.       }
  21. }

    运行结果：


    P.S.
    1、父类中的私有方法不可以被覆盖。
    2、父类为static的方法无法覆盖。
    3、覆盖时，子类方法权限一定要大于等于父类方法权限。

    示例：
  1. class Fu{
  2.        public void show(){
  3.             System.out.println("fu show run" );
  4.       }
  5. }

  7. class Zi extends Fu{
  8.        private void show(){
  9.             System.out.println("zi show run" );
  10.       }
  11. }

  13. class ExtendDemo{
  14.        public static void main(String[] args){
  15.             Zi z = new Zi();
  16.             z.show();
  17.       }
  18. }

    运行结果：


    3. 构造函数

        子父类中构造函数的特点：
        在子类构造函数执行时，发现父类构造函数也运行了。
        原因：在子类的构造函数中，第一行有一个默认的隐式语句：super();。
        注意：如果使用super(4);语句调用父类的其他构造函数，那么默认的父类构造函数将不会再被调用。

    示例：
  1. class Fu{
  2.       int num ;
  3.       Fu(){
  4.             num = 10;
  5.             System.out.println("A fu run" );
  6.       }
  7.       Fu(int x){
  8.             System.out.println("B fu run..." + x);
  9.       }
  10. }

  12. class Zi extends Fu{
  13.       Zi(){
  14.             //super();//默认调用的就是父类中的空参数的构造函数
  15.             System.out.println("C zi run " + num);
  16.       }
  17.       Zi(int x){
  18.             super(4);
  19.             System.out.println("D zi run " + x);
  20.       }
  21. }

  23. class ExtendDemo{
  24.        public static void main(String[] args){
  25.             new Zi();
  26.             System.out.println("-------------------" );
  27.             new Zi(6);
  28.       }
  29. } 

    运行结果：


4.4 子类的实例化过程

    子类中所有的构造函数默认都会访问父类中空参数的构造函数。
    因为每一个构造函数的第一行都有一条默认的语句super();。

    为什么子类实例化的时候要访问父类中的构造函数呢？
    那是因为子类继承了父类，获取到了父类中内容（属性），所以在使用父类内容之前，要先看父类是如何对自己的内容进行初始化的。

    P.S.
    1、当父类中没有空参数的构造函数时，子类的构造函数必须通过this或者super语句指定要访问的构造函数。
    2、子类构造函数中如果使用this调用了本类构造函数，那么默认的super();就没有了，因为super和this都只能定义在第一行，所以只能有一个。但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数。
    3、super语句必须要定义在子类构造函数的第一行！因为父类的初始化动作要先完成。

    示例：
  1. class Fu{
  2.       Fu(){
  3.              super();
  4.              //调用的是子类的show方法，此时其成员变量num还未进行显示初始化
  5.              show();
  6.              return;
  7.       }
  8.       void show(){
  9.             System.out.println("fu show" );
  10.       }
  11. }
  12. class Zi extends Fu{
  13.        int num = 8;
  14.        Zi(){
  15.              super();
  16.              //通过super初始化父类内容时，子类的成员变量并未显示初始化，等super()父类初始化完毕后，才进行子类的成员变量显示初始化
  17.              return;
  18.        }
  19.        void show(){
  20.             System.out.println("zi show..." + num);
  21.        }
  22. }
  23. class ExtendDemo{
  24.        public static void main(String[] args){
  25.             Zi z = new Zi();
  26.             z.show();
  27.        }
  28. }

    运行结果：
 

    总结：
    一个对象实例化过程，以Person p = new Person();为例：
    1. JVM会读取指定的路径下的Person.class文件，并加载进内存，并会先加载Person的父类（如果有直接的父类的情况下）。
    2. 在内存中开辟空间，并分配地址。
    3. 并在对象空间中，对对象的属性进行默认初始化。
    4. 调用对应的构造函数进行初始化。
    5. 在构造函数中，第一行会先到调用父类中构造函数进行初始化。
    6. 父类初始化完毕后，再对子类的属性进行显示初始化。
    7. 再进行子类构造函数的特定初始化。
    8. 初始化完毕后，将地址值赋值给引用变量。

4.5 final关键字

    final可以修饰类，方法，变量。
    final修饰的类不可以被继承。
    final修饰的方法不可以被覆盖。

    final修饰的变量是一个常量，只能被赋值一次。

    为什么要用final修饰变量，其实，在程序中如果一个数据是固定的。那么直接使用这个数据就可以了，但是这种阅读性差，所以应该给数据起个名称。而且这个变量名称的值不能变化，所以加上final固定。
    写法规范：常量所有字母都大写，多个单词，中间用_连接。

    示例1：
  1. //继承弊端：打破了封装性
  2. class Fu{
  3.        void method(){
  4.        }
  5. }

  7. class Zi extends Fu{
  8.        public static final double PI = 3.14;
  9.        void method(){
  10.             System.out.println(PI);
  11.        }
  12. }

  14. class FinalDemo{
  15.        public static void main(String[] args){
  16.             Zi zi = new Zi();
  17.             zi.method();
  18.        }
  19. }

   运行结果：

    示例2：
  1. class FinalDemo{
  2.        public static void main(String[] args){
  3.             final int x = 4;
  4.             x = 5;
  5.        }
  6. }

    运行结果：


4.6 抽象类

    4.6.1 抽象类概述

    抽象定义：
    抽象就是从多个事物中将共性的、本质的内容抽取出来。
    例如：狼和狗共性都是犬科，犬科就是抽象出来的概念。

    抽象类：
    Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。

    抽象方法的由来：
    多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。
    例如：狼和狗都有吼叫的方法，可是吼叫内容是不一样的。所以抽象出来的犬科虽然有吼叫功能，但是并不明确吼叫的细节。

    4.6.2 抽象类的特点

    抽象类和抽象方法必须用abstract关键字来修饰。

    抽象方法只有方法声明，没有方法体，定义在抽象类中。
    格式：修饰符 abstract 返回值类型 函数名(参数列表) ;

    抽象类不可以被实例化，也就是不可以用new创建对象。
    原因如下：
    1. 抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例。例如：犬科是一个抽象的概念，真正存在的是狼和狗。
    2. 而且抽象类即使创建了对象，调用抽象方法也没有意义。
    3. 抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类。

    示例：
  1. abstract class Demo{
  2.        abstract /*抽象*/ void show();
  3. }

  5. class DemoA extends Demo{
  6.        void show(){
  7.             System.out.println("demoa show" );
  8.        }
  9. }

  11. class DemoB extends Demo{
  12.        void show(){
  13.             System.out.println("demob show" );
  14.        }
  15. }

  17. class AbstractDemo{
  18.        public static void main(String[] args){
  19.             DemoA demoA = new DemoA();
  20.             demoA.show();

  22.             DemoB demoB = new DemoB();
  23.             demoB.show();     
  24.        }
  25. }

   运行结果：


    4.6.3 抽象类举例代码讲解  

    需求：
   公司中程序员有姓名，工号，薪水，工作内容。
   项目经理除了有姓名，工号，薪水，还有奖金，工作内容。

    分析：
    在这个问题领域中，通过名词提炼法：
    程序员：
    属性：姓名，工号，薪水。
    行为：工作。
    经理：
    属性：姓名，工号，薪水，奖金。
    行为：工作。

    程序员和经理不存在着直接继承关系。
    但是，程序员和经理却具有共性内容，可以进行抽取，因为他们都是公司的雇员。
    可以将程序员和经理进行抽取，建立体系。

    代码：
  1. //描述雇员。
  2. abstract class Employee{
  3.        private String name ;
  4.        private String id ;
  5.        private double pay ;

  7.       Employee(String name,String id, double pay){
  8.              this.name = name;
  9.              this.id = id;
  10.              this.pay = pay;
  11.       }

  13.        public abstract void work();
  14. }

  16. //描述程序员
  17. class Programmer extends Employee{
  18.       Programmer(String name,String id, double pay){
  19.              super(name,id,pay);
  20.       }

  22.        public void work(){
  23.             System.out.println("code..." );
  24.        }
  25. }

  27. //描述经理
  28. class Manager extends Employee{
  29.       private int bonus ;
  30.       
  31.       Manager(String name,String id, double pay,int bonus){
  32.              super(name,id,pay);
  33.              this.bonus = bonus;
  34.       }

  36.       public void work(){
  37.             System.out.println("manage" );
  38.       }
  39. }


    4.6.4 抽象类相关问题

    抽象类中是否有构造函数？
    答：有，用于给子类对象进行初始化。

    抽象关键字abstract不可以和哪些关键字共存？
    答：private、static、final。

    抽象类中可不可以没有抽象方法？
    答：可以，但是很少见。目的就是不让该类创建对象，AWT的适配器对象就是这种类。通常这个类中的方法有方法体，但是却没有内容。

    示例：
  1. abstract class Demo{
  2.      void show1(){}
  3.      void show2(){}
  4. }


    抽象类和一般类的区别？
    答：
    相同点：
    抽象类和一般类都是用来描述事物的，都在内部定义了成员。

    不同点：
    1. 一般类有足够的信息描述事物。
        抽象类描述事物的信息有可能不足。
    2. 一般类中不能定义抽象方法，只能定义非抽象方法。
       抽象类中可定义抽象方法，同时也可以定义非抽象方法。
    3. 一般类可以被实例化。
       抽象类不可以被实例化。

    抽象类一定是个父类吗？
    答：是的，因为需要子类覆盖其方法后才可以对子类实例化。

4.7 接口

    当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是接口。

    格式：interface {}

    接口中的成员修饰符是固定的：
    成员常量：public static final
    成员函数：public abstract
    由此得出结论，接口中的成员都是公共的权限。

    接口是对外暴露的规则。
    接口是程序的功能扩展。

    P.S.
    1、虽然抽象类中的全局变量和抽象方法的修饰符都可以不用写，但是这样阅读性很差。所以，最好写上。
    2、类与类之间是继承关系，类与接口直接是实现关系。
    3、接口不可以实例化，能由实现了接口并覆盖了接口中所有的抽象方法的子类实例化。否则，这个子类就是一个抽象类。

    示例：
  1. interface Demo{
  2.        public static final int NUM = 4;
  3.        public abstract void show1();
  4.        public abstract void show2();
  5. }

  7. class DemoImpl implements /*实现*/Demo{
  8.        public void show1(){}
  9.        public void show2(){}
  10. }

  12. class InterfaceDemo{
  13.        public static void main(String[] args){
  14.             DemoImpl d = new DemoImpl();
  15.             System.out.println(d.NUM);
  16.             System.out.println(DemoImpl.NUM);
  17.             System.out.println(Demo.NUM);
  18.       }
  19. }

    运行结果：


    接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。

    在java中不直接支持多继承，因为会出现调用的不确定性。
    所以，java将多继承机制进行改良，在java中变成了多实现，一个类可以实现多个接口。
    接口的出现避免了单继承的局限性。

    示例：
  1. interface A{
  2.        public void show();
  3. }

  5. interface Z{
  6.        public void show();
  7. }

  9. //多实现
  10. class Test implements A,Z{
  11.        public void show(){
  12.             System.out.println("Test");
  13.        }
  14. }

  16. class InterfaceDemo{
  17.        public static void main(String[] args){
  18.             Test t = new Test();
  19.             t.show();
  20.        }
  21. }

    运行结果：


    一个类在继承另一个类的同时，还可以实现多个接口。

    示例1：
  1. interface A{
  2.        public void show();
  3. }

  5. interface Z{
  6.        public void show();
  7. }

  9. class Q{
  10.     public void method(){
  11.     }
  12. }

  14. abstract class Test2 extends Q implements A,Z{
  15.    
  16. }


    示例2：
  1. interface CC{
  2.        void show();
  3. }

  5. interface MM{
  6.        void method();
  7. }

  9. //接口与接口之间是继承关系，而且接口可以多继承
  10. interface QQ extends CC,MM{
  11.        public void function();
  12. }

  14. class WW implements QQ{
  15.        //覆盖3个方法
  16.        public void show(){}
  17.        public void method(){}
  18.        public void function(){}
  19. } 


    抽象类和接口的异同点？
    相同点：
    都是不断向上抽取而来的。
    不同点：
    1. 抽象类需要被继承，而且只能单继承。
        接口需要被实现，而且可以多实现。
    2. 抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
        接口中只能定义抽象方法，必须由子类去实现。
    3. 抽象类的继承，是is a关系，定义该体系的基本共性内容。
        接口的实现是like a关系。  

接口应用综合案例

    代码：
  1. /*
  2. 笔记本电脑使用。
  3. 为了扩展笔记本的功能，但日后出现什么功能设备不知道。
  4. 因此需要定义一个规则，只要日后出现的设备都符合这个规则就可以了。
  5. 规则在java中就是接口。
  6. */
  7. interface USB{//暴露的原则
  8.        public void open();
  9.        public void close();
  10. }

  12. //实现原则
  13. //这些设备和电脑的耦合性降低了
  14. class UPan implements USB{
  15.        public void open(){
  16.             System.out.println("upan open");
  17.        }
  18.        public void close(){
  19.             System.out.println("upan close");
  20.        }
  21. }

  23. class UsbMouse implements USB{
  24.        public void open(){
  25.             System.out.println("usbMouse open");
  26.        }
  27.        public void close(){
  28.             System.out.println("usbMouse close");
  29.        }
  30. }

  32. class BookPC{
  33.        public static void main(String[] args){
  34.              //功能扩展了
  35.              useUSB(new UPan());
  36.        }
  37.        //使用原则
  38.        public static void useUSB(USB u){//接口类型的引用，用于接收（指向）接口的子类对象
  39.              if(u != null ){
  40.                   u.open();
  41.                   u.close();
  42.              }
  43.        }
  44. }

0 0
淘宝时尚初秋长袖睡衣 淘宝时尚初秋长袖睡衣
原创粉丝点击
热门IT博客
2017年网络红歌2017年网络红歌
森田药妆面膜 知乎森田药妆面膜 知乎
麦茶 日本 知乎
mac apt get install
cctv直播软件下载
魔蝎数据20-0是什么
js从入门到精通pdf
c 目标识别分类算法
位图转换矢量图软件
淘宝售假是什么意思
淘宝运营团队收费
淘宝嘉年华女装
世界跑步鞋排名 知乎
人工智能 数据挖掘
畅销进销存软件
北风网大数据全套视频
写字板软件下载
淘宝怎么让人代付
java 图片加水印
java html 转换为xml
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 诸葛亮特点 信用证特点 青铜器特点 zigbee特点 天秤男特点 特点英文 仙人掌特点 真菌的特点 dna复制特点 鸡血石特点 紫外线特点 网球的特点 绿茶的特点 90后特点 银杏叶特点 ix25特点 投资的特点 的特点 足球鞋特点 语音的特点 特点 英文 比熊犬特点 注意的特点 民间故事特点 孙悟空性格特点 人物性格特点 目标管理特点包括 说明文的特点 孩子的性格特点怎么写 美式风格特点 美式风格特点有哪些 java语言特点 b型血的性格特点 法式风格特点 孩子的特点怎么写 云计算的特点是什么 孙悟空的性格特点 我国民族分布特点 博美犬有什么特点 简约美式风格特点 现代欧式风格特点

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里