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修饰不让子类访问,所以他俩是矛盾的

面向对象(2)之抽象类