zoukankan      html  css  js  c++  java
  • java面向对象编程(八)--抽象类、接口

    1、抽象类

    1.1抽象类概念

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

    //抽象类的必要性[Demo124.java]
    public class Demo124 {
        public static void main(String[] args) {
            //Animal an=new Animal();抽象类不允许实例化
            Animal an=new Cat();
            an.cry();
            an=new Dog();
            an.cry();
        }
    }
    //抽象类abstract关键词
    abstract class Animal{
        String name;
        int age;
        //动物会叫,使用了abstract抽象方法
        //抽象类中可以没有abstract抽象方法 
        abstract public void cry();
        //抽象类内可以有实现方法
        public void sx(){
            System.out.println("实现方法");
        }
    }
    //当一个子类继承的父类是abstract抽象类的话,需要程序员把抽象类的抽象方法全部实现。
    class Cat extends Animal{
        //实现父类的cry,其实类似上节学习中的子类覆盖父类
        public void cry(){
            System.out.println("猫猫叫");
        }
    }
    class Dog extends Animal{
        //实现父类的cry,其实类似上节学习中的子类覆盖父类
        public void cry(){
            System.out.println("汪汪叫");
        }
    }

    1.1、抽象类--深入讨论

    抽象类是java中一个比较重要的类。

    1、用abstract关键字来修饰一个类时,这个类就是抽象类。

    2、用abstract关键字来修饰一个方法时,这个方法就是抽象方法。

    3、abstract抽象类中的abstract抽象方法是不允许在抽象类中实现的,一旦实现就不是抽象方法和抽象类了。abstract抽象方法只能在子类中实现。

    4、抽象类中可以拥有实现方法。

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

    1.2、抽象类--注意事项

    1、抽象类不能被实例化

    2、抽象类不一定要包含abstract方法。也就是说,抽象类可以没有abstract抽象方法。

    3、一旦类包含了abstract抽象方法,则这个类必须声明为abstract抽象类。

    4、抽象方法不能有主体。

        正确的抽象方法例:abstract void abc();

        错语的抽象方法例:abstract void abc(){}

    2、接口

    2.1、什么是接口?

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

    接口的建立语法:

    interface 接口名{
        方法;
    }

    实现接口语法:

    class 类名 implements 接口{
          方法;
          变量;
    }

    接口是更加抽象的抽象的类,抽象类里的方法可以有方法体,接口里的所有方法都没有方法体。接口体现了程序设计的多态和高内聚低偶合的设计思想。

    案例:

    //接口的实现[Demo125.java]
    //电脑,相机,u盘,手机
    
    //usb接口
    interface Usb{
        int a=1;//加不加static都是静态的,不能用private和protected修饰
        //声明了两个方法
        public void start();//接口开始工作
        public void stop();//接口停止工作
    }
    //编写了一个相机类,并实现了usb接口
    //一个重要的原则:当一个类实现了一个接口,要求该类把这个接口的所有方法全部实现
    class Camera implements Usb{
        public void start(){
            System.out.println("我是相机,开始工作了..");
        }
        public void stop(){
            System.out.println("我是相机,停止工作了..");
        }
    }
    //接口继承别的接口
    class Base{
    }
    interface Tt{
    }
    interface Son extends Tt{
    }
    //编写了一个手机,并实现了usb接口
    class Phone implements Usb{
        public void start(){
            System.out.println("我是手机,开始工作了..");
        }
        public void stop(){
            System.out.println("我是手机,停止工作了..");
        }
    }
    //计算机
    class Computer{
        //开始使用usb接口
        public void useUsb(Usb usb){
            usb.start();
            usb.stop();
        }
    }
    public class Demo125 {
        public static void main(String[] args) {
            System.out.println(Usb.a);
            //创建 Computer
            Computer computer=new Computer();
            //创建Camera
            Camera camera=new Camera();
            //创建Phone
            Phone phone=new Phone();
            computer.useUsb(camera);
            computer.useUsb(phone);
        }
    }

    注意事项

      (1)、接口不能被实例化

      (2)、接口中所有的方法都不能有主体。错误语法例:void aaa(){}←(注意不能有花括号)

    接口可以看作更加抽象的抽象类。

      (3)、一个类可以实现多个接口

      (4)、接口中可以有变量[但变量不能用private和protected修饰]

          a、接口中的变量,本质上都是static的而且是final类型的,不管你加不加static修饰

          b、在java开发中,我们经常把常用的变量,定义在接口中,作为全局变量使用

                  访问形式:接口名.变量名

      (5)、一个接口不能继承其它的类,但是可以继承别的接口

    3、实现接口VS继承类

    java的继承是单继承,也就是一个类最多只能有一个父类,这种单继承的机制可保证类的纯洁性,比C++中的多继承机制简洁。但是不可否认,对子类功能的扩展有一定影响。所以:

    1、实现接口可以看作是对继承的一种补充。(继承是层级式的,不太灵活。修改某个类就会打破继承的平衡,而接口就没有这样的麻烦,因为它只针对实现接口的类才起作用)

    2、实现接口可在不打破继承关系的前提下,对某个类功能扩展,非常灵活。

    //实例:建立子类并继承了父类且连接多个接口[Demo126.java]
    public class Demo126 {
        public static void main(String[] args) {
            System.out.println("继承了Monkey父类");
            Monkey mo=new Monkey();
            mo.jump();
            LittleMonkey li=new LittleMonkey();
            li.swimming();
            li.fly();
        }
    }
    //接口Fish
    interface Fish{
        public void swimming();
    }
    //接口Bird
    interface Bird{
        public void fly();
    }
    //建立Monkey类
    class Monkey{
        int name;
        //猴子可以跳
        public void jump(){
            System.out.println("猴子会跳!");
        }
    }
    //建立LittleMonkey子类并继承了Monkey父类并连接了Fish和Bird接口
    class LittleMonkey extends Monkey implements Fish,Bird{
        public void swimming() {
            System.out.println("连接了Fish接口!");
        }
        public void fly() {
            System.out.println("连接了Bird接口!");
        }
    }

    4、用接口实现多态

    java中多态是个难以理解的概念,但同时又是一个非常重要的概念。java三大特性之一(继承,封装,多态),我们可以从字面上简单理解:就是一种类型的多种状态,以下通过卖小汽车的例子说明什么是多态。

    案例:

    //用接口实现多态
    public class Demo127 {
        public static void main(String []args){
            CarShop aShop=new CarShop();
            //卖出一辆宝马
            aShop.sellCar(new BMW());
            //卖出一辆奇瑞QQ
            aShop.sellCar(new CheryQQ());
            //卖出一辆桑塔纳
            aShop.sellCar(new Santana());
            System.out.println("总收入:"+aShop.getMoney());
        }
    }
    //汽车接口
    interface Car{
        //汽车名称
        String getName();
        //获得汽车售价
        int getPrice();
    }
    //宝马
    class BMW implements Car{
        public String getName(){
            return "BMW";
        }
        public int getPrice(){
            return 300000;
        }
    }
    //奇瑞QQ
    class CheryQQ implements Car{
        public String getName(){
            return "CheryQQ";
        }
        public int getPrice(){
            return 20000;
        }
    }
    //桑塔纳汽车
    class Santana implements Car{
        public String getName(){
            return "Santana";
        }
        public int getPrice(){
            return 80000;
        }
    }
    //汽车出售店
    class CarShop{
        //售车收入
        private int money=0;        
        //卖出一部车
        public void sellCar(Car car){
         System.out.println("车型:"+car.getName()+"单价:"+car.getPrice());
            //增加卖出车售价的收入
            money+=car.getPrice();
        }
        //售车总收入
        public int getMoney(){
            return money;
        }
    }
    
     
    运行结果:
    车型:BMW 单价:300000
    车型:CheryQQ 单价:20000
    总收入:320000

    继承是多态得以实现的基础。从字面上理解,多态就是一种类型(都是Car类型)表现出多种状态(宝马汽车的名称是BMW,售价是300000;奇瑞汽车的名称是CheryQQ,售价是2000)。将一个方法调用同这个方法所属的主体(也就是对象或类)关联起来叫做绑定,分前期绑和后期绑定两种。下面解释一下它们的定义:

    1、前期绑定:在程序运行之前进行绑定,由编译器和连接程序实现,又叫做静态绑定。比如static方法和final方法,注意,这里也包括private方法,因为它是隐式final的。

    2、后期绑定:在运行时根据对象的类型进行绑定,由方法调用机制实现,因此又叫做动态绑定,或者运行时绑定。除了前期绑定外的所有方法都属于后期绑定。

    多态就是在后期绑定这种机制上实现的。多态给我们带来的好处是消除了类之间的偶合关系,使程序更容易扩展。比如在上例中,新增加一种类型汽车的销售。只需要让新定义的类实现Car类并实现它的所有方法,而无需对原有代码做任何修改,CarShop类的sellCar(Carcar)方法就可以处理新的车型了。新增代码如下:

    //桑塔纳汽车
    class Santana implements Car{
        public String getName(){
            return "Santana";
        }
        public int getPrice(){
            return 80000;
        }
    }

    至此,关于类的定义又可以更进一步得到完善:

    package 包名;
    class 类名 extends 父类 implements 接口名{
            成员变量;
            构造方法;
            成员方法;
    }
  • 相关阅读:
    Hibernate中session的产生的方式
    Hibernate 多对多关联Demo
    Hibernate 一对多双向关联Demo
    Beta(0/7)
    获得小黄衫感想(2)
    软工实践作业(十)
    成员交换情况
    Alpha事后诸葛亮
    Alpha冲刺总结
    Alpha(10/10)
  • 原文地址:https://www.cnblogs.com/Davis812/p/3921280.html
Copyright © 2011-2022 走看看