面向对象(2)之抽象类

1.抽象类概念和特点

* A:抽象类概述

* 抽象就是看不懂的

* B:抽象类特点

* a:抽象类和抽象方法必须用abstract关键字修饰

* abstract class 类名 {}

* public abstract void eat();//当不知道该方法具体是怎么实现的

//比如动物吃，你知道它吃什么吗？怎么吃？都不知道

* b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口

* c:抽象类不能实例化那么，抽象类如何实例化呢?

* 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。

* d:抽象类的子类

* 要么是抽象类

* 要么重写抽象类中的所有抽象方法

*C:案例

public class Demo1_Abstrat {
    public static void main(String[] args){
        Animal q = new Cat();//编译看左边，运行看右边，子类构造方法访问父类构造方法
        q.eat();
    }

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

    public Animal(){
        System.out.println("父类空参构造");
    }
}
class Cat extends Animal{
    public Cat(){
        //super();
    }

    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("猫吃鱼");
    }
}

输出：

父类空参构造
猫吃鱼

注意：

Animal q = new Cat();访问子类空参然后空参访问父类构造方法，所以父类空参输出先输出

2.抽象类案例

A.

class Demo3_葵花宝典 {
//抽象父类的方法必须在非抽象子类中重写
    public static void main(String[] args) {
        岳不群 小岳子 = new 岳不群();
            小岳子.自宫();
        }
}
abstract class 葵花宝典 {
    public abstract void 自宫();
}
class 岳不群 extends 葵花宝典 {
    public void 自宫() {
    System.out.println("用牙签");
    }
}
class 林平之 extends 葵花宝典 {
    public void 自宫() {
    System.out.println("用指甲刀");
        }
}
class 东方不败 extends 葵花宝典 {
    public void 自宫() {
    System.out.println("用锤子,不忍直视");
        }
} 
输出结果：
用牙签
注意：
运行逻辑：岳不群 小岳子 = new 岳不群();当类中无构造方法时不去访问非构造方法，只代表创建对象或者初始化（赋值），与类中有构造方法的运行逻辑分开。

B.

A:案例演示

* 具体事物：猫，狗

* 共性：姓名，年龄，吃饭

* 猫的特性:抓老鼠

* 狗的特性:看家

    Cat c = new Cat("加菲",8);
        System.out.println(c.getName() + "..." + c.getAge());
        c.eat();
        c.catchMouse();
        Dog d = new Dog("八公",30);
        System.out.println(d.getName() + "..." + d.getAge());
            d.eat();
            d.lookHome();
}
}
abstract class Animal {
           private String name;                //姓名
             private int age;                    //年龄
             public Animal(){}                    //空参
             public Animal(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 eat();            //吃饭}
         class Cat extends Animal {
         public Cat(){}                    //空参
         public Cat(String name,int age) {//有参
         super(name,age);
}
        public void eat() {
            System.out.println("猫吃鱼");
 }
        public void catchMouse() {
            System.out.println("抓老鼠");
        }
      }
}
class Dog extends Animal {
            public Dog(){}                    //空参
        public Dog(String name,int age) {//有参
            super(name,age);    }
        public void eat() {
            System.out.println("狗吃肉");    }
        public void lookHome() {
            System.out.println("看家");
     }

}
class Cat extends Animal {
        public Cat(){}                    //空参
        public Cat(String name,int age) {//有参
        super(name,age);    }
        public void eat() {
        System.out.println("猫抓老鼠");    }
        public void catchMouse() {
        System.out.println("看家");
 }

}

输出结果：

加菲...8
猫抓老鼠
看家
八公...30
狗吃肉
看家

注意：抽象类我的理解就是一些类所共有的属性与方法的集合，抽象类中抽象方法在子类中必须继承或者重写。

C.

* 假如我们在开发一个系统时需要对程序员类进行设计，程序员包含3个属性：姓名、工号以及工资。

* 经理，除了含有程序员的属性外，另为还有一个奖金属性。

* 请使用继承的思想设计出程序员类和经理类。要求类中提供必要的方法进行属性访问

public class Test_Employee {
    public static void main(String[] args) {
        Coder a = new Coder("张三", 12, 21626);
        a.work();

        Manager h = new Manager("李四", 12, 222, 223244);
        h.work();
    }
}

abstract class Employ {
    private String name;
    private int id;
    private int salary;

    public Employ(String name, int id, int salary) {
        this.name = name;
        this.id = id;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    public abstract void work();//抽象方法

}

class Coder extends Employ {

    public Coder(String name, int id, int salary) {
        super(name, id, salary);
        // TODO Auto-generated constructor stub

    }

    public void work() {
        // super(name,id,salary);
        System.out.println(this.getId()+“ ” + this.getName()+“ ” + this.getSalary());
    }

}
//项目经理
class Manager extends Employ {
    private int bonus;

    public Manager(String name, int id, int salary, int bonus) {
        super(name, id, salary);
        // TODO Auto-generated constructor stub
        this.bonus = bonus;//注意这点
    }

    public void work() {
        System.out.println(this.getId()+“ ” + this.getName()+“ ” + this.getSalary()+“ ”
                + bonus);//注意这点
    }
}

运行结果：

12 张三 21626
12 李四 222 223244

注意：

本案例我一直纠结在项目经理的特有属性如何处理，后来发现只要在项目经理类中定义个属性并在方法中多加了一个参数就ok了，这点暴露出我的思维不够灵活，this.bonus = bonus其中this指当前对象，这句话相当于对象调用属性并且赋值.

3.面试题

* A:面试题1
* 一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
             * 可以
             * 这么做目的只有一个,就是不让其他类创建本类对象,交给子类完成
* B:面试题2
             * abstract不能和哪些关键字共存
               abstract和static
               被abstract修饰的方法没有方法体
               被static修饰的可以用类名.调用,但是类名.调用抽象方法是没有意义的
               abstract和final
              被abstract修饰的方法强制子类重写
              被final修饰的不让子类重写,所以他俩是矛盾
              abstract和private
              被abstract修饰的是为了让子类看到并强制重写
              被private修饰不让子类访问,所以他俩是矛盾的

时间： 2024-08-26 10:13:19

面向对象(2)之抽象类的相关文章

面向对象基础之抽象类与接口 下

在上篇博文中我们一起了解了抽象类,那么什么是接口呢?下面给大家简单介绍一下: 所谓接口,就是把隐式公共方法和属性组合起来,以封装特定功能的一个集合.一旦类实现了接口,类就可以支持接口所指定的所有属性和成员.声明接口在语法上与声明抽象类完全相同,但不允许提供接口中任何成员的执行方式,因此接口不能实例化,不能有构造方法和字段,不能有修饰符,如public等.在实现接口的类中必须实现接口中的所有方法和属性. 一个接口可以支持多个接口,多个类也可以支持相同的接口.需要注意的是,接口用interface关

面向对象设计中抽象类与接口的区别

在OOD(面向对象设计)中,经常会用到抽象类或接口,[注:在C++中,没有接口的概念,只有抽象类:而在Java中两者都存在].而在使用过程中,也许会有不少人认为接口和抽象类差不多,然后就想当然地觉得可以相互完全替换.事实上,虽然他们有很多相似点,但也有很大差异. 1.抽象类与接口的出现条件 在面向对象的概念中,我们知道所有的对象都是通过类来描绘的,但是反过来却不是这样.并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类.抽象类往往用来表征我们

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.cr

Python基础（17）_面向对象程序设计（抽象类、继承原理、封装、多态，绑定方法）

一.抽象类 抽象类是一个特殊的类,它的特殊之处在于只能被继承,不能被实例化 1.在python中实现抽象类 import abc #利用abc模块实现抽象类 class All_file(metaclass=abc.ABCMeta): all_type='file' @abc.abstractmethod #定义抽象方法,无需实现功能 def read(self): '子类必须定义读功能' pass @abc.abstractmethod #定义抽象方法,无需实现功能 def write(sel

Java面向对象----->接口和抽象类

抽象类和接口(一)在实际的项目中,整个项目的代码一般可以分为结构代码和逻辑的代码.就像建造房屋时,需要首先搭建整个房屋的结构,然后再细化房屋相关的其它的结构,也像制造汽车时,需要首先制作汽车的框架,然后才是安装配件以及美化等工作.程序项目的实现也遵循同样的道理.在项目设计时,一个基本的原则就是--"设计和实现相分离".也就是说结构代码和逻辑代码的分离,就像设计汽车时只需要关注汽车的相关参数,而不必过于关心如何实现这些要求的制作.程序设计时也是首先设计项目的结构,而不用过多的关系每个逻辑

《Java技术》第三次作业--面向对象——继承、抽象类、接口

一)学习总结 1.阅读下面程序,分析是否能编译通过?如果不能,说明原因.应该如何修改?程序的运行结果是什么?为什么子类的构造方法在运行之前,必须调用父 类的构造方法?能不能反过来? class Grandparent { public Grandparent() { System.out.println("GrandParent Created."); } public Grandparent(String string) { System.out.println("Gran

面向对象的理解 抽象类&接口

一.关于面向对象 1.什么是面向对象 在解释面向对象之前,先说说面向过程.学过C的同学都知道,C就是面向过程的一种语言.那什么是面向过程呢?比方说组装主机,对于面向过程,需要从0开始.买cpu,显卡,主板,电源,风扇,把这些都通过主板链接到一起.我需要清楚的知道主机组装的每一个步骤. 介绍了面向过程,再说会正题,什么是面向对象?对于上面的装主机过程面向对象会把主机先抽象成一个机箱,机箱里有cpu,显卡,主板,电源.用主机的人,不关心里面是怎么工作的,也不需要知道内部逻辑,只知道插上电源就能用.面

20141014C#面向对象抽象方法，抽象类，接口

里氏代换原则.可以用子类的对象替代父类的对象. 抽象依赖原则.依赖——形参,关联 一.抽象方法: 在一些父类中,某些行为不是非常明确,因此无法用代码来具体实现,但是类必须具备此方法,因此把这样的方法定义为抽象方法.abstract 特点:1.只声明,不实现.2.加abstract关键字. eg: 1 public abstract class Ren //类中含有抽象方法,此类也必须是抽象类. 2 { 3 public abstract void Eat(); //以分号结束,没有花括号 4 }

黑马程序员——Java基础——面向对象——继承、抽象类、接口、多态、包、内部类、异常等

第一讲 继承 1.继承: 当多个类拥有相同的功能时,那么这些类不需要每个都写这些相同的功能,只需要把相同功能抽到 一个单独的类中,继承这个类就能获得这些相同的功能: (1)继承的体系结构:就是对要描述的事物进行不断的向上抽取,就出现了体系结构. 要了解这个体系结构中最共性的内容,就看最顶层的类. 要使用这个体系的功能,就用最底层的类创建对象 (2)好处: A.提高代码复用性: B.继承的出现,让类与类之间产生关系,为多态的前提 (3)特点: A.只能单继承(准确的说是java对多继承进行优化,避