原Java学习笔记019 - 面向对象
Posted iflytek
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了原Java学习笔记019 - 面向对象相关的知识，希望对你有一定的参考价值。
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 Animal 16 // 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 // @Override 41 // 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 @Override 41 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 class 47 //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 permitted 31 // 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 Problem 59 // 重写抽象的成员方法 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 protected 26 // 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 protected 31 // 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 protected 36 // 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 @Override 101 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 @Override 116 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 // @Override 25 // public void fly() { 26 // System.out.println("老鹰的飞行"); 27 // } 28 //} 29 // 30 //// 具体子类：麻雀类 31 //class Sparrow extends Bird { 32 // @Override 33 // 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 // @Override 49 // 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 Ability 18 // 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 body 39 //// public void fly() { 40 //// 41 //// } 42 // 43 // // 接口中的方法必须是抽象的 44 // public abstract void fly(); 45 //} 46 // 47 //// 具体的飞机类 实现 能力接口 48 //class Plane implements Ability { 49 // @Override 50 // 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 assigned 20 // 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 permitted 33 // private int x = 99; 34 35 // 构造函数 36 // 语法错误：Interfaces cannot have constructors 37 // public Test() { 38 // 39 // } 40 41 // 成员方法 42 // 非抽象的成员方法 43 // 语法错误：Abstract methods do not specify a body 44 // 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 permitted 51 // private abstract void method2(); 52 } 53 54 // 接口的实现类 55 class TestImpl implements Test { 56 @Override 57 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 ",", . expected 37 //class Son extends Father, Mother { 38 // 语法错误：The type Eat cannot be the superclass of Son; a superclass must be a class 39 //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 expected 58 //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 @Override 45 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 @Override 100 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 // 考虑到系别是子类的特征，所以定义为static 111 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 @Override 124 public void study(String course) { 125 System.out.println("学习" + course); 126 } 127 128 @Override 129 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 }
以上是关于原Java学习笔记019 - 面向对象的主要内容，如果未能解决你的问题，请参考以下文章