原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 - 面向对象的主要内容,如果未能解决你的问题,请参考以下文章

原Java学习笔记015 - 面向对象

原Java学习笔记017 - 面向对象

原Java学习笔记026 - 集合

Java学习笔记

Java学习笔记之十三初探Java面向对象的过程及代码实现

java学习笔记之面向对象多态