抽象类的一些基本概念
抽象方法：在Java中，一个没有方法体的方法定义为抽象方法。抽象类：类中如果有抽象方法，该类定义为抽象类。1>抽象类的概述： 动物不应该定义为具体的东西，而且动物中的吃，睡等也不应该是具体的。 我们把一个不是具体的功能称为抽象的功能，而一个类中如果有抽象的功能，该类必须是抽象类。 2>抽象类的特点： A:抽象类和抽象方法必须用abstract关键字修饰 B:抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类 C:抽象类不能实例化 因为它不是具体的。 抽象类有构造方法，但是不能实例化?构造方法的作用是什么呢? 用于子类访问父类数据的初始化 D:抽象的子类 a:如果不想重写抽象方法，该子类是一个抽象类。 b:重写所有的抽象方法，这个时候子类是一个具体的类。 抽象类的实例化其实是靠具体的子类实现的。是多态的方式。 Animal a = new Cat();3>抽象类的成员特点： 成员变量：既可以是变量，也可以是常量。 构造方法：有。 用于子类访问父类数据的初始化。 成员方法：既可以是抽象的，也可以是非抽象的。4> 抽象类的成员方法特性： A:抽象方法 <强制要求子类做的事情>。 B:非抽象方法 <子类继承的事情，提高代码复用性>
代码块
代码块语法遵循标准markdown代码，例如：
abstract class Animal{ int age=20; final int age2=40; public Animal() {} public Animal(String name,int age) {} public abstract void show(); public void method(){ System.out.println("Animal method"); } }class Dog extends Animal{ public void show(){ System.out.println(""); }}public class AbstactDemo2 { public static void main(String[] args) { Animal a=new Dog(); a.age=10; System.out.println(a.age); System.out.println(a.age2); }}
-----------------------------------------
-------------------------------------------------------
问题描述
抽象类的练习
学生案例：
具体类：一般学生 优秀学生
共性：姓名 年龄 年纪
吃饭
差异： 学习内容
代码块
代码块语法遵循标准markdown代码，例如：
abstract class student { private String name; private int age; private int grand; public student(){} public student(String name,int age,int grand){ this.name=name; this.age=age; this.grand=grand; } 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 void setgrand(int grand){ this.grand=grand; } public int getgrand(){ return grand; } abstract public void study(); public void eat(){ System.out.println("该吃饭了："); }}class Basicstudent extends student { public Basicstudent(){} public Basicstudent(String name,int age,int grand){ super(name,age,grand); } public void study(){ System.out.println("Basicstudent: study"); }}class Goodstudent extends student{ public Goodstudent(){} public Goodstudent(String name,int age,int grand){ super(name,age,grand); } public void study(){ System.out.println("Goodstudent: study"); }}public class AbstractTest3{ public static void main(String[] args){ student s =new Basicstudent(); s.setname("Basicstudent1"); s.setage(20); s.setgrand(1111); System.out.println(s.getname()+"----"+s.getage()+"----"+s.getgrand()); s.eat(); s.study(); s =new Basicstudent("Basicstudent1",20,2222); System.out.println(s.getname()+"----"+s.getage()+"----"+s.getgrand()); s.eat(); s.study(); }}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
答案
Basicstudent1—-20—-1111
该吃饭了：
Basicstudent: study
Basicstudent1—-20—-2222
该吃饭了：
Basicstudent: study
-----------------------------------------------------------
抽象类的练习
学生案例：
具体类：一般员工 优秀员工
共性：姓名 工号 薪水
差异： 做事 奖金
代码块
代码块语法遵循标准markdown代码，例如：
abstract class employee{ private String name; private String id; private int salary; public employee(){} public employee(String name,String id,int salary){ this.name=name; this.id=id; this.salary=salary; } public void setname(String name){ this.name=name; } public String getname(){ return name; } public void setid(String id){ this.id=id; } public String getid(){ return id; } public void setsalary(int salary){ this.salary=salary; } public int getsalary(){ return salary; } public abstract void work();}class Basicemployee extends employee{ public Basicemployee(){} public Basicemployee(String name,String id,int salary){ super(name,id,salary); } public void work(){ System.out.println("做简单工作："); }}class Goodempoyee extends employee{ private int money; public Goodempoyee() {} public Goodempoyee(String name,String id,int salary,int money){ super(name,id,salary); this.money=money; } public void setmoney(int money){ this.money=money; } public int getmoney(){ return money; } public void work(){ System.out.println("做高级工作："); } }class AbstractTest4{ public static void main(String[] args){ employee emp=new Basicemployee(); emp.setname("Basicemployee-1"); emp.setid("qwe0001"); emp.setsalary(10001); System.out.println(emp.getname()+"----"+emp.getid()+"----"+emp.getsalary()); emp=new Basicemployee("Basicemployee-2","qwe0002",10002); System.out.println(emp.getname()+"----"+emp.getid()+"----"+emp.getsalary()); Goodempoyee emp2=new Goodempoyee(); emp2.setname("Goodempoyee-3"); emp2.setid("qwe0003"); emp2.setsalary(30000); emp2.setmoney(10000); System.out.println(emp2.getname()+"----"+emp2.getid()+"----"+emp2.getsalary()+"----"+emp2.getmoney()); }}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
答案
Basicemployee-1—-qwe0001—-10001
Basicemployee-2—-qwe0002—-10002
Goodempoyee-3—-qwe0003—-30000—-10000
--------------------------------------------------
接口的一些基本概念
抽象方法：在Java中，一个没有方法体的方法定义为抽象方法。抽象类：类中如果有抽象方法，该类定义为抽象类。1>抽象类的概述： 动物不应该定义为具体的东西，而且动物中的吃，睡等也不应该是具体的。 我们把一个不是具体的功能称为抽象的功能，而一个类中如果有抽象的功能，该类必须是抽象类。 2>接口特点： A:接口用关键字interface表示 格式：interface 接口名{} B:类实现接口用implements表示 格式：class 类名 implements 接口名{} C:接口不能实例化 那么如何实例化？ 按照多态的方式，由具体的子类实例化，其实这也是多态的一种，接口多态。 D:接口的子类 a:要么是抽象类。 b:要么重写接口中的所有抽象方法。3>接口的成员特点： 成员变量：只能是常量；默认修饰符public static final; 构造方法：没有。因为接口主要是拓展功能的，而没有具体存在。 成员方法：只能是抽象方法，默认修饰符public abstract.4> 抽象类的成员方法特性： A:抽象方法 <强制要求子类做的事情>。 B:非抽象方法 <子类继承的事情，提高代码复用性>
代码块
代码块语法遵循标准markdown代码，例如：
interface AnimalTrain{ public abstract void jump();}class Cat implements AnimalTrain{ public void jump(){ System.out.println("猫可以跳高了"); }}public class InterfaceDemo { public static void main(String[] args) { Cat at =new Cat(); at.jump(); }}
接口的特点
interface Inter { public int num = 10; public final int num2 = 20; public static final int num3 = 30; public void show(); }class InterImpl extends Object implements Inter { public InterImpl() { super(); } public void show() {}}class InterfaceDemo2 { public static void main(String[] args) { Inter i = new InterImpl(); System.out.println(i.num); System.out.println(i.num2); System.out.println(Inter.num); System.out.println(Inter.num2); System.out.println("--------------"); }}
-------------------------
猫狗案例
猫狗案例,加入跳高的额外功能分析：从具体到抽象 猫： 姓名,年龄 吃饭，睡觉 狗： 姓名,年龄 吃饭，睡觉 由于有共性功能，所以，我们抽取出一个父类： 动物： 姓名,年龄 吃饭(); 睡觉(){} 猫：继承自动物 狗：继承自动物 跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口 接口： 跳高 部分猫：实现跳高 部分狗：实现跳高实现； 从抽象到具体使用： 使用具体类
代码块
interface Jumpping{ public abstract void jump();}abstract class Animal{ private String name; private int 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; } Animal(){} Animal(String name,int age){ this.name=name; this.age=age; } public abstract void eat(); public void sleep(){ System.out.println("该睡觉了"); }}class Cat extends Animal{ public Cat() {} public Cat(String name,int age){ super(name,age); } public void eat(){ System.out.println("猫吃鱼："); }}class Dog extends Animal{ public Dog(){} public Dog(String name,int age){ super(name,age); } public void eat(){ System.out.println("狗吃肉："); }}class JumpCat extends Cat implements Jumpping{ public JumpCat() {} public JumpCat(String name,int age){ super(name,age); } public void jump(){ System.out.println("跳高猫"); }}class JumpDog extends Dog implements Jumpping{ public JumpDog(){} public JumpDog(String name,int age){ super(name,age); } public void jump(){ System.out.println("跳高狗"); }}public class InterfaceTest { public static void main(String[] args){ JumpCat jc = new JumpCat(); jc.setname("哆啦A梦"); jc.setage(5); System.out.println(jc.getname()+"----"+jc.getage()+"岁了"); jc.eat(); jc.sleep(); jc.jump(); JumpCat jc2= new JumpCat("哆啦B梦",4); System.out.println(jc2.getname()+"----"+jc2.getage()+"岁了"); jc2.eat(); jc2.sleep(); jc2.jump(); }}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
答案
哆啦A梦—-5岁了
猫吃鱼：
该睡觉了
跳高猫
哆啦B梦—-4岁了
猫吃鱼：
该睡觉了
跳高猫
-------------------------------------------------
教练和运动员案例(学生分析然后讲解) 乒乓球运动员和篮球运动员。 乒乓球教练和篮球教练。 为了出国交流，跟乒乓球相关的人员都需要学习英语。 请用所学知识： 分析，这个案例中有哪些抽象类，哪些接口，哪些具体类。
代码块
interface SpeakEnglish { public abstract void speak();}abstract class Person { private String name; private int age; public Person() {} public Person(String name,int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public void sleep() { System.out.println("人都是要睡觉的"); } public abstract void eat();}abstract class Player extends Person { public Player() {} public Player(String name,int age) { super(name,age); } public abstract void study();}abstract class Coach extends Person { public Coach() {} public Coach(String name,int age) { super(name,age); } public abstract void teach();}class PingPangPlayer extends Player implements SpeakEnglish { public PingPangPlayer(){} public PingPangPlayer(String name,int age) { super(name,age); } public void eat() { System.out.println("乒乓球运动员吃大白菜，喝小米粥"); } public void study() { System.out.println("乒乓球运动员学习如何发球和接球"); } public void speak() { System.out.println("乒乓球运动员说英语"); }}class BasketballPlayer extends Player { public BasketballPlayer(){} public BasketballPlayer(String name,int age) { super(name,age); } public void eat() { System.out.println("篮球运动员吃牛肉，喝牛奶"); } public void study() { System.out.println("篮球运动员学习如何运球和投篮"); }}class PingPangCoach extends Coach implements SpeakEnglish { public PingPangCoach(){} public PingPangCoach(String name,int age) { super(name,age); } public void eat() { System.out.println("乒乓球教练吃小白菜，喝大米粥"); } public void teach() { System.out.println("乒乓球教练教如何发球和接球"); } public void speak() { System.out.println("乒乓球教练说英语"); }}class BasketballCoach extends Coach { public BasketballCoach(){} public BasketballCoach(String name,int age) { super(name,age); } public void eat() { System.out.println("篮球教练吃羊肉，喝羊奶"); } public void teach() { System.out.println("篮球教练教如何运球和投篮"); }}class InterfaceTest3 { public static void main(String[] args) { PingPangPlayer ppp = new PingPangPlayer(); ppp.setName("王浩"); ppp.setAge(33); System.out.println(ppp.getName()+"---"+ppp.getAge()); ppp.eat(); ppp.sleep(); ppp.study(); ppp.speak(); System.out.println("----------------"); BasketballPlayer bp = new BasketballPlayer(); bp.setName("姚明"); bp.setAge(34); System.out.println(bp.getName()+"---"+bp.getAge()); bp.eat(); bp.sleep(); bp.study(); }}
--------------------------------------
