黑马程序员_多态、抽象类、接口

---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流！ ----------------------

 

        今天是学习面向对象部分的第四天，经过前面几天的学习，我们已经对面向对象有了基本的了解，今天的学习内容有多态，抽象类，接口。

1：多态

        多态的定义：多态是同一个对象在不同时刻表现出来的多种状态。

        例如：水在不同温度下不同的状态就可以称之为多态。

        多态的前提：

            要有继承关系或者实现关系。

            要有子类重写父类或者父接口的方法。

            要有父类引用或者父接口引用指向子类对象。

        

        多态中成员的特点：

            成员变量：编译看左边，运行看左边

            静态方法：编译看左边，运行看左边

            成员方法：编译看左边，运行看右边

        多态中的转型：

            向上转型：从子类型转到父类型

            向下转型：从父类型转到子类型，包含强制类型转换。

        多态的好处：

            提高代码的可维护性。

            提高程序的扩展性。

        多态的弊端：不能使用子类中的特有功能。如果要使用子类的特有功能，只能通过子类对象进行访问。

    

例如：

class Father {
    private int num = 10;
    
    public void show() {
        System.out.println("father show");
    }
    
class Son extends Father {
    int num = 20;
     int num2 = 30;    
    public void show() {
        System.out.println("son show");
    }  
    
    public void method() {
        System.out.println("son method");
    }  
}

class FatherTest {
    public static void main(String[] args) {
       Father f = new Son();               //向上转型

       System.out.println(f.num);
       System.out.println(f.num2);        //父类不能访问子类的特有方法，编译报错

      f.show();
       
       Son s = (Son)f;                //向下转型

       System.out.println(s.num);
       System.out.println(f.num2); 
       s.show();
       s.method();
    }
}

        在上面的例子程序中， Father f = new Son();就是多态的应用，父类的引用指向子类的对象，访问成员变量的运行结果是父类中的变量值，访问成员方法的运行的是子类的成员方法。

2：抽象类：

        抽象类的定义：把多个类中相同的方法声明进行抽取，定义到一个类中。一个方法只有方法声明而没有方法体就叫做抽象方法，有抽象方法的类必须定为抽象类。

        抽象类的特点：

            抽象类和抽象方法都要用关键字abstract修饰。

            有抽象类的方法一定是抽象类，抽象类中不一定有抽象方法。

            类继承抽象类的时候，要么实现抽象类中的所有抽象方法，要么这个类本身也定义为抽象类。

            抽象类不能被实例化，也就是说抽象类不能创建对象。

       抽象类的成员特点：

            成员变量：可以是变量，也可以是常量

            构造方法：有构造方法

            成员方法：可以是抽象方法，也可以是非抽象方法

        抽象类的好处：

            抽象类中的非抽象方法提高了代码的复用性

            要求子类必须做某些事情。

        注意事项：

            抽象类虽然不能创建对象，订但是抽象类有构造方法，用于子类调用父类数据的初始化

            抽象类中没有抽象方法的目的是为了不被创建对象

        不能和抽象类关键字abstract一起用的关键字有：private，static，final

            private：权限修饰符，私有的。私有的方法不能被重写，而abstract要求重写

            final：最终的。被final修饰的类要被继承，被final修饰的方法不能被重写，而被abstract修饰的类要被继承，被abstract修饰的方法要求被重写，两个关键字之间的作用发生冲突

            static：静态修饰符，静态的方法可以通过类名调用，而抽象的方法没有方法体，通过类名调用没有意义。

3：接口

        接口的定义：为了表示一个类中的所有方法都是抽象的，java提供了一种更抽象的表现形式，就是接口。                 

        接口的特点：

            接口用关键字interface表示。

            类实现接口用关键字implements表示。

            类实现接口的时候，要么重写接口中的所有抽象方法，要么这个类也定义为抽象类。

            接口不能被实例化。

        接口的成员特点：

            成员变量：只能是常量，因为接口的成员变量前有默认修饰符：public static final

            成员方法：是抽象方法，接口的成员变量前面有默认修饰符：public abstract

        接口的思想特点：

            接口是对外暴露的规则

            接口的出现降低了耦合性

            接口是扩展功能

        接口与类之间的关系：

            类与类之间的关系是继承关系，只能单继承，不能多继承，可以多层继承

            类与接口之间的关系是实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口。

            接口与接口之间的关系是继承关系，可以单继承，也可以多继承。‘

4：抽象类和接口之间的区别：

        成员区别：

                抽象类：

                    成员变量：可以是变量，也可以是常量

                    成员方法：可以是抽象的，也可以是非抽象的

                    构造方法：有构造方法，用于子类调用父类的数据初始化

                接口：

                    成员变量：是常量，因为有默认修饰符：public static final

                    成员方法：是抽象方法，因为有默认修饰符：public abstract

        设计理念的区别：

                类继承体现的是is a的关系，父类中一般定义的是共性功能

                接口的实现体现的是like a 的关系，接口中一般定义的是扩展功能。

下面这个例子就是对今天所学内容的综合运用：

 //*
  传智播客的老师有基础班的，也有就业班的。
  共性：
 属性：姓名，年龄
 功能：讲课。
  现在又要针对日语这种小语种单独开班，需要部分基础班老师和部分就业班老师会说日语。
  请用所学知识把上面的内容用代码体现。
  分析：从具体到抽象
  实现：从抽象到具体
  使用：使用具体类
  分析：
 基础班老师
  部分基础班老师
 就业班老师
  部分就业班老师
 老师：
  姓名，年龄
  讲课。
 接口：
  说日语
*/
//说日语的接口


interface SpeakJapanese {
 public abstract void speak();
}
//抽象老师类


abstract class Teacher {
 private String name;
 private int age;
 public Teacher(){}
 public Teacher(String name,int age) {
  this.name = name;
  this.age = age;
 }
 public void setName(String name) {
  this.name = name;
 }
 public String getName() {
  return name;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public int getAge() {
  return age;
 }
 public abstract void teach();
}

//基础班老师


class BasicTeacher extends Teacher {
 public BasicTeacher(){}
 public BasicTeacher(String name,int age){
  super(name,age);
 }
 public void teach() {
  System.out.println("基础班老师讲Java基础");
 }
}

//就业班老师


class JiuYeTeacher extends Teacher {

 public JiuYeTeacher(){}

 public JiuYeTeacher(String name,int age){

  super(name,age);

 }

 public void teach() {

  System.out.println("就业班老师讲javaEE");

 }

}



//部分基础班老师


class PartBasicTeacher extends BasicTeacher implements SpeakJapanese {
 public PartBasicTeacher(){}
 public PartBasicTeacher(String name,int age){
  super(name,age);
 }
 public void speak() {
  System.out.println("会说日语的基础班老师");
 }
}

//部分就业班老师


class PartJiuYeTeacher extends JiuYeTeacher implements SpeakJapanese {

 public PartJiuYeTeacher(){}

 public PartJiuYeTeacher(String name,int age){

  super(name,age);

 }

 public void speak() {

  System.out.println("会说日语的就业班老师");

 }

}

class TeacherTest {
 public static void main(String[] args) {
  PartBasicTeacher pbt = new PartBasicTeacher();
  pbt.setName("林青霞");
  pbt.setAge(27);
  System.out.println(pbt.getName()+"---"+pbt.getAge());
  pbt.teach();
  pbt.speak();
  PartJiuYeTeacher pjyt = new PartJiuYeTeacher("刘亦菲",22);
  System.out.println(pjyt.getName()+"---"+pjyt.getAge());
  pjyt.teach();
  pjyt.speak();
 } 
}

---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流！ ----------------------详细请查看：<a href="http://www.itheima.com" target="blank">www.itheima.com</a>

         

            

转载于:https://my.oschina.net/u/1390204/blog/285041