1 package cn.temptation; 2  3 public class Sample01 { 4     public static void main(String[] args) { 5         // 仔细想一想，Animal应该是一个抽象的概念，相对于Animal来说，狗才是具体的概念 6         // Animal的行为也应该算是一个抽象的行为 7          8         // Java中对于这些抽象的概念或是抽象的行为，提供了一个关键字  abstract   来进行修饰 9         10         // 关键字 abstract用在类上，类称为抽象类：abstract class 类名11         // 关键字 abstract用在方法上，方法称为抽象方法：abstract 返回类型   方法名(参数列表)12 13         // 抽象类不能进行实例化14         // 原因：既然这个Animal类都是抽象的概念了，自然无法具体的创建出一个对象来，所以不能被实例化15         // 语法错误：Cannot instantiate the type Animal16 //        Animal animal = new Animal();17         18         // 抽象类不能直接实例化使用，但是可以通过继承使用，使用多态写法19 //        Animal animal = new Dog();20         // 对于子类的成员方法，编译看赋值号左边，执行看赋值号右边21 //        animal.eat();22     }23 }24 25 //// 抽象类26 //abstract class Animal {27 //    // 成员方法28 //    // 语法错误：Abstract methods do not specify a body    抽象方法没有方法体29 ////    public abstract void eat() {30 ////        System.out.println("动物会吃");31 ////    }32 //    33 //    // 成员方法上使用了abstract，就变成了一个抽象成员方法34 //    // 没有方法体，意味着没有具体的实现，只是定义35 //    public abstract void eat();36 //}37 //38 //// 具体实现子类39 //class Dog extends Animal {40 //    @Override41 //    public void eat() {42 //        System.out.println("狗会吃");43 //    }44 //}

 1 package cn.temptation; 2  3 public class Sample02 { 4     public static void main(String[] args) { 5         // 抽象类 和 抽象成员方法的特点： 6         // 1、抽象类中可以有抽象的成员方法，也可以有非抽象的成员方法 7         // 2、只要类中有抽象的成员方法，该类就必须得是抽象类 8         // 3、抽象的成员方法没有方法体，只有小括号没有大括号，但是有分号作为结尾 9         // 4、抽象类不能被实例化，因为它被修饰为抽象的10         // 5、抽象类可以有构造函数；虽然其构造函数不是用来做实例化的操作，但是可以提供给其子类创建对象时使用11         // 6、抽象类的子类也可以是一个抽象类12         // 7、不论抽象类中的成员方法是否为抽象的，只要类是抽象的，就不能实例化，也就不能使用对象名.成员方法来进行调用13     }14 }15 16 // 抽象父类17 abstract class Animal {18     // 构造函数19     public Animal() {20         System.out.println("无参构造函数");21     }22     23     // 成员方法24     // 抽象的成员方法25     public abstract void eat();26     27     // 非抽象的成员方法28     public void sleep() {29         System.out.println("动物能睡觉");30     }31 }32 33 // 抽象子类34 abstract class Dog extends Animal {35 36 }37 38 // 抽象子类的具体实现的孙类39 class ChineseDog extends Dog {40     @Override41     public void eat() {42         System.out.println("中国狗会吃");43     }44 }45 46 // The abstract method test in type Demo can only be defined by an abstract class47 //class Demo {48 //    // 抽象的成员方法49 //    public abstract void test();50 //}

 1 package cn.temptation; 2  3 public class Sample03 { 4     public static void main(String[] args) { 5         // 抽象类成员的使用问题： 6         // 1、成员变量：可以是变量，也可以是自定义常量 7         // 2、构造函数：构造函数不是用来做实例化的，但是是提供给子类使用的 8         // 3、成员方法：可以是抽象的，也可以是非抽象的 9         //        抽象的成员方法：强制具体实现子类实现父类的抽象成员方法10         //        非抽象的成员方法：子类可以重写、也可以不重写11         12         Human human = new Man();13         System.out.println(human.i);14         System.out.println(human.X);15     }16 }17 18 // 抽象类19 abstract class Human {20     // 成员变量21     public int i = 2;22     public final int X = 3;23     24     // 构造函数（无参）25     public Human() {26         System.out.println("无参构造函数");27     }28     29     // 构造函数不能使用abstract修饰30     // 语法错误：Illegal modifier for the constructor in type Human; only public, protected & private are permitted31 //    public abstract Human();32     33     // 构造函数（有参）34     public Human(int i) {35         this.i = i;36         System.out.println(i);37     }38     39     // 成员方法40     // 抽象的成员方法41     public abstract void eat();42     43     // 非抽象的成员方法44     public void sleep() {45         System.out.println("人能睡觉");46     }47 }48 49 // 具体实现子类50 class Man extends Human {51     // 构造函数52     public Man() {53         super(99);54     }55 56     // 成员方法57     // 不重写就会生成语法错误58     // 语法错误：The type Man must implement the inherited abstract method Human.eat()    Sample03.java    /Day20170302_OOP/src/cn/temptation    line 48    Java Problem59     // 重写抽象的成员方法60     public void eat() {61         62     }63 }

 1 package cn.temptation; 2  3 public class Sample04 { 4     public static void main(String[] args) { 5         // 调用抽象类的静态成员变量 和 静态成员方法，使用类名.静态成员，无视该类是否为抽象类 6 //        System.out.println(Phone.number); 7 //        Phone.call(); 8     } 9 }10 11 abstract class Phone {12     // 静态成员变量13 //    static int number = 110;14     15     // 静态成员方法16 //    static void call() {17 //        System.out.println("打电话");18 //    }19     20     // 抽象的成员方法21     public abstract void method1();22     23     // private 和 abstract同时修饰，语法错误。24     // 理解：private要求的是私有的，而abstract提出抽象的概念，需要后代去做实现，所以语义上是矛盾的25     // 语法错误：The abstract method method2 in type Phone can only set a visibility modifier, one of public or protected26 //    private abstract void method2();27     28     // final 和 abstract同时修饰，语法错误。29     // 理解：final要求的是子类不能重写父类的成员方法，而abstract提出抽象的概念，需要后代去做实现，所以语义上是矛盾的30     // 语法错误：The abstract method method3 in type Phone can only set a visibility modifier, one of public or protected31 //    final abstract void method3();32     33     // static 和 abstract同时修饰，语法错误。34     // 理解：static要求的是对象们（类的）的成员方法，而abstract提出抽象的概念（不是具体的），所以语义上是矛盾的35     // 语法错误：The abstract method method4 in type Phone can only set a visibility modifier, one of public or protected36 //    static abstract void method4();37 }

  1 package cn.temptation;  2   3 public class Sample05 {  4     public static void main(String[] args) {  5         // 需求：使用学过的知识点实现  6         //        东汉公司的员工都不睡觉  7         //        1、东汉公司的码农    吕布   是公司的员工，他写代码、打游戏，拿很少的薪水（1680）  8         //        2、东汉公司的经理   貂蝉 也是公司的员工，她做管理、听音乐，拿很多的薪水（20000）  9          10         Staff.companyName = "东汉"; 11          12         Staff staff1 = new Programmer("吕布", 1680); 13         System.out.println("姓名为：" + staff1.getName() + "，薪资为：" + staff1.getSalary() + "，公司名为：" + Staff.companyName); 14         staff1.nosleep(); 15         staff1.work(); 16         ((Programmer)staff1).playGame(); 17          18         Staff staff2 = new Manager(); 19         staff2.setName("貂蝉"); 20         staff2.setSalary(20000); 21         System.out.println("姓名为：" + staff2.getName() + "，薪资为：" + staff2.getSalary() + "，公司名为：" + Staff.companyName); 22         staff2.nosleep(); 23         staff2.work(); 24         ((Manager)staff2).listenMusic(); 25     } 26 } 27  28 /** 29  * 抽象类：员工类 30  */ 31 abstract class Staff { 32     // 成员变量 33     // 名字 34     private String name; 35     // 薪资 36     private int salary; 37     // 公司名 38     public static String companyName; 39  40     // 构造函数（无参） 41     public Staff() { 42          43     } 44  45     public Staff(String name, int salary) { 46         super(); 47         this.name = name; 48         this.salary = salary; 49     } 50  51     // 成员方法 52     public String getName() { 53         return name; 54     } 55  56     public void setName(String name) { 57         this.name = name; 58     } 59  60     public int getSalary() { 61         return salary; 62     } 63  64     public void setSalary(int salary) { 65         this.salary = salary; 66     } 67      68     // 自定义成员方法 69     /** 70      * 抽象成员方法：工作 71      * 等着具体实现子类去进行实现 72      */ 73     public abstract void work(); 74      75     /** 76      * 非抽象成员方法：不睡觉 77      * 不想被子类重写，可以使用final进行修饰 78      */ 79     public final void nosleep() { 80         System.out.println("不睡觉"); 81     } 82 } 83  84 /** 85  * 子类：程序员类 86  */ 87 class Programmer extends Staff { 88     // 成员变量 89      90     // 构造函数 91     public Programmer() { 92         super(); 93     } 94      95     public Programmer(String name, int salary) { 96         super(name, salary); 97     } 98      99     // 成员方法100     @Override101     public void work() {102         System.out.println("写代码");103     }104     105     public void playGame() {106         System.out.println("打游戏");107     }108 }109 110 /**111  * 子类：经理类112  */113 class Manager extends Staff {114     // 成员方法115     @Override116     public void work() {117         System.out.println("做管理");118     }119     120     public void listenMusic() {121         System.out.println("听音乐");122     }123 }

 1 package cn.temptation; 2  3 public class Sample06 { 4     public static void main(String[] args) { 5 //        Bird bird1 = new Eagle();                // 老鹰是一种鸟 6 //        bird1.fly(); 7 //         8 //        Bird bird2 = new Sparrow();                // 麻雀是一种鸟 9 //        bird2.fly();10 //        11 //        Bird bird3 = new Plane();                // 飞机是一种鸟12 //        bird3.fly();13     }14 }15 16 //// 抽象类：鸟类17 //abstract class Bird {18 //    // 抽象方法：飞行19 //    public abstract void fly();20 //}21 //22 //// 具体子类：老鹰类23 //class Eagle extends Bird {24 //    @Override25 //    public void fly() {26 //        System.out.println("老鹰的飞行");27 //    }28 //}29 //30 //// 具体子类：麻雀类31 //class Sparrow extends Bird {32 //    @Override33 //    public void fly() {34 //        System.out.println("麻雀的飞行");35 //    }36 //}37 //38 //// 为了让飞机能飞行，强行让飞机从抽象父类鸟类进行继承，这样很别扭39 //// 究其原因，因为子类继承父类，得到了父类的特征和行为（非私有的），这是一种先天的联系40 //// 但是，在现实的世界中，除了描述先天上的联系，还有描述后天的关联41 //// 这里的飞机会飞行，这不是先天上的天赋，而是后天具有的能力42 //// 对于这些后天具备的能力，还去使用描述先天联系的继承去实现，就显得别扭了43 //44 //// 对于描述后天具备的能力，Java中提供了   接口（interface）    机制45 //46 //// 具体子类：飞机类47 //class Plane extends Bird {48 //    @Override49 //    public void fly() {50 //        System.out.println("飞机的飞行");51 //    }52 //}

 1 package cn.temptation; 2  3 public class Sample07 { 4     public static void main(String[] args) { 5         // 接口：描述事物具有的能力 6          7         // 格式：interface   接口名     { ... } 8          9         // 接口的实现形式： class 类名     implements  接口名   { .... }10         11         // 注意：12         // 1、接口不能实例化13         // 2、如何使用接口？14         //         A：通过实现接口的类使用接口15         //        B：重写接口中定义的成员方法（类似抽象类的实现子类中的重写）16         17         // 语法错误：Cannot instantiate the type Ability18 //        Ability ability = new Ability();19         20         // 常规写法（类的实例化）21 //        Plane plane = new Plane();22 //        plane.fly();23         24         // 多态写法25 //        Ability plane = new Plane();        // 飞机具备能力26 //        plane.fly();27         28         // 关于多态及其重写使用的场合：29         // 1、非抽象类继承后的多态（不常见）30         // 2、抽象类继承后的多态（常见）31         // 3、接口实现后的多态（常见）32     }33 }34 35 //// 接口：能力接口36 //interface Ability {37 //    // 接口中的方法没有方法体38 //    // 语法错误：Abstract methods do not specify a body39 ////    public void fly() {40 ////        41 ////    }42 //    43 //    // 接口中的方法必须是抽象的44 //    public abstract void fly();45 //}46 //47 //// 具体的飞机类 实现 能力接口48 //class Plane implements Ability {49 //    @Override50 //    public void fly() {51 //        System.out.println("飞机 的飞行");52 //    }53 //}

 1 package cn.temptation; 2  3 public class Sample08 { 4     public static void main(String[] args) { 5         // 接口的成员： 6         // 1、成员变量： 7         //        接口中的成员变量支持的修饰符：public static final 数据类型  成员变量名 8         //        通过对接口的字节码文件的反编译，发现接口中的成员变量的修饰符都是public static final修饰的，也就是这些成员变量都是接口的自定义常量 9         // 2、构造函数10         //        接口不能有构造函数（接口不能实例化）11         // 3、成员方法12         //         接口中的方法必须是抽象的，不能是非抽象的13         //        接口中的所有方法（都是抽象方法）必须要在实现类中进行实现14         Test obj = new TestImpl();15         System.out.println(obj.i);16         System.out.println(obj.j);17         System.out.println(obj.k);18         19         // 语法错误：The final field Test.i cannot be assigned20 //        obj.i = 99;21         22         // 注意："不能实例化的就一定没有构造函数"这种说法对不对？         答：不对，例如：抽象类23     }24 }25 26 // 接口27 interface Test {28     // 成员变量29     public int i = 2;30     public final int j = 4;31     public static final int k = 6;32     // 语法错误：Illegal modifier for the interface field Test.x; only public, static & final are permitted33 //    private int x = 99;34     35     // 构造函数36     // 语法错误：Interfaces cannot have constructors37 //    public Test() {38 //        39 //    }40     41     // 成员方法42     // 非抽象的成员方法43     // 语法错误：Abstract methods do not specify a body44 //    public void method() {45 //        46 //    }47     48     // 抽象的成员方法49     public abstract void method1();50     // 语法错误：Illegal modifier for the interface method method2; only public, abstract, default, static and strictfp are permitted51 //    private abstract void method2();52 }53 54 // 接口的实现类55 class TestImpl implements Test {56     @Override57     public void method1() {58         59     }60 }

 1 package cn.temptation; 2  3 public class Sample09 { 4     public static void main(String[] args) { 5         // 1、类     和      类之间的关系 6         //        类和类之间可以是继承的关系（extends  关键字    inheritance） 7         //        Java中的继承（针对类）是单继承，可以有继承链 8          9         // 2、类     和      接口之间的关系10         //      类和接口之间是实现的关系（implements  关键字  implement）11         //        Java中的实现可以是单实现（具备某一种能力），也可以是多实现（具备多种能力）12         //        注意：类与接口之间是实现的关系，没有继承的关系13         14         // 3、接口     和      接口之间的关系15         //        接口 和 接口之间可以是单继承，也可以是多继承16         //        注意：接口不能实现另一个接口，因为接口定义的是规范，不是实现17         18         // 面试题：19         // Java语言是单继承、多实现的（×）20         // 答：对于类，是单继承、多实现的；对于接口，是可以单继承，也可以多继承，但是不能实现其他接口或类21     }22 }23 24 class GrandFather {25     26 }27 28 class Father extends GrandFather {29     30 }31 32 class Mother {33     34 }35 36 // 语法错误：Syntax error on token ",", . expected37 //class Son extends Father, Mother {38 // 语法错误：The type Eat cannot be the superclass of Son; a superclass must be a class39 //class Son extends Eat {40 class Son extends Father implements Eat, Sleep {41     42 }43 44 interface Eat {45     46 }47 48 interface Sleep {49     50 }51 52 // 接口可以多继承53 //interface Lazy extends Eat, Sleep {54 //    55 //}56 57 // 语法错误：Syntax error on token "implements", extends expected58 //interface Lazy implements Eat {59 //interface Lazy implements Sleep {    60 //}

 1 package cn.temptation; 2  3 public class Sample10 { 4     public static void main(String[] args) { 5         // 抽象类     和       接口的区别 6         /* 7          * 1、成员上的区别： 8          * 抽象类： 9          * A：成员变量：可以是变量，也可以是常量10          * B：构造函数：有，但是不能实例化，只能供子类调用11          * C：成员方法：可以有抽象的成员方法，也可以有非抽象的成员方法12          * 13          * 接口：14          * A：成员变量：都是常量（自定义常量）15          * B：构造函数：没有构造函数16          * C：成员方法：都是抽象的成员方法17          * 18          * 2、关系上的区别：19          * 类和类：单继承20          * 类和接口：类可以是单实现接口，也可以是多实现接口21          * 接口和接口：接口可以是单继承接口，也可以是多继承接口22          * 23          * 3、设计意图上的区别：24          * 抽象类：描述的是先天的天赋，有着抽象的概念、抽象的行为和具体实现子类是继承的关系，对于继承的具体实现子类来说描述了"is a(an)"的含义25          *         抽象类中定义的成员是这些子类以及它们的后代共有的特征和行为（且不好具体描述）26          * 接口：描述的是后天培养的、具备的能力，供类实现或是给其他接口继承，描述的是"like a(an)"或"as a(an)"的含义27          *         接口中定义的是被实现的类需要扩展的功能28          */29         30         // 【面向对象设计原则之一："开闭原则"-----"对扩展开放，对修改封闭"】31         // 换句话说，在面向对象的设计中，建议多使用接口，少使用继承32         // 对于接口，应该理解其"规范性、强制性"的特点33     }34 }35 36 // 接口：能力接口37 interface Ability {38     // 接口中的方法必须是抽象的39     public abstract void fly();40 }41 42 class Plane implements Ability {43     // 实现了Ability接口，具备了接口定义的能力（方法）44     @Override45     public void fly() {46         System.out.println("飞机能飞");47     }48 }

  1 package cn.temptation;  2   3 public class Sample11 {  4     public static void main(String[] args) {  5         // 需求：使用学过的知识（例如：抽象类、接口等）实现如下功能  6         // 1、吕布是个体育系的男学生，20岁，学习Java，会打篮球（因为是体育系的）  7         // 2、貂蝉是个音乐系的女学生，16岁，学习乐理，会弹棉花（因为是音乐系的）  8           9         Student student1 = new PE("吕布", 20, "男"); 10         student1.study("Java"); 11         ((PE)student1).doSport("篮球"); 12          13         Student student2 = new MusicalStudent("貂蝉", 16, "女"); 14         student2.study("乐理"); 15         ((MusicalStudent)student2).doEquipment("棉花"); 16     } 17 } 18  19 // 抽象类：学生类 20 abstract class Student { 21     // 成员变量 22     // 姓名 23     private String name; 24     // 年龄 25     private int age; 26     // 性别 27     private String gender; 28     // 系别 29     public static String dept = ""; 30  31     // 构造函数 32     public Student() { 33         super(); 34     } 35  36     public Student(String name, int age, String gender, String dept) { 37         super(); 38         this.name = name; 39         this.age = age; 40         this.gender = gender; 41         Student.dept = dept; 42          43         System.out.println("姓名为：" + this.name + "，年龄为：" + this.age + "，性别为：" + this.gender + "，系别为：" + Student.dept); 44     } 45  46     // 成员方法 47     public String getName() { 48         return name; 49     } 50  51     public void setName(String name) { 52         this.name = name; 53     } 54  55     public int getAge() { 56         return age; 57     } 58  59     public void setAge(int age) { 60         this.age = age; 61     } 62  63     public String getGender() { 64         return gender; 65     } 66  67     public void setGender(String gender) { 68         this.gender = gender; 69     } 70  71     // 自定义的成员方法 72     // 考虑到学生先天的天赋行为有学习，所以在抽象类中制作一个抽象方法study 73     public abstract void study(String course); 74 } 75  76 /** 77  * 具体实现子类：体育系学生 78  */ 79 class PE extends Student implements Sport { 80     // 成员变量 81     // 考虑到系别是子类的特征，所以定义为static 82     public static String dept = "体育系"; 83  84     // 构造函数 85     public PE() { 86         super(); 87     } 88      89     public PE(String name, int age, String gender) { 90         super(name, age, gender, PE.dept); 91     } 92      93     // 成员方法 94     @Override 95     public void study(String course) { 96         System.out.println("学习" + course); 97     } 98  99     @Override100     public void doSport(String sportName) {101         System.out.println("做" + sportName + "运动");102     }103 }104 105 /**106  * 具体实现子类：音乐系学生107  */108 class MusicalStudent extends Student implements Equipment {109     // 成员变量110     // 考虑到系别是子类的特征，所以定义为static111     public static String dept = "音乐系";112 113     // 构造函数114     public MusicalStudent() {115         super();116     }117     118     public MusicalStudent(String name, int age, String gender) {119         super(name, age, gender, MusicalStudent.dept);120     }121     122     // 成员方法123     @Override124     public void study(String course) {125         System.out.println("学习" + course);126     }127 128     @Override129     public void doEquipment(String equipmentName) {130         System.out.println("演奏" + equipmentName + "器械");131     }132 }133 134 // 运动能力接口135 interface Sport {136     public abstract void doSport(String sportName);137 }138 139 // 器械能力接口140 interface Equipment {141     public abstract void doEquipment(String equipmentName);142 }