JavaSE学习总结第09天_面向对象4
2015-05-17 00:51
387 查看
09.01 final关键字引入
例:
上面的代码中父类中的show()方法如果不想被子类覆盖，可以使用final关键字修饰，当子类覆盖了父类中的show()方法，将会报以下错误:
final关键字是最终的意思，可以修饰类，成员变量，成员方法
09.02 final关键字修饰类,方法以及变量的特点
修饰类，类不能被继承
修饰方法，方法不能被重写
修饰变量，变量就变成了常量，只能被赋值一次
09.03 final关键字修饰局部变量
例:
final修饰基本类型的局部变量，该变量的值不能被改变
final修饰引用类型的局部变量，引用类型的地址值不能变
09.04 final修饰变量的初始化时机
例:
09.05 多态的概述和前提条件
多态概述:某一个对象，在不同时刻表现出来的不同状态。
举例:猫可以是猫的类型。Cat c = new Cat();
同时猫也是动物的一种，也可以把猫称为动物。Animal a = new Animal();
多态的前提:
1.有继承关系
2.有方法重写
3.有父类引用指向子类对象
09.06 按照多态前提给出代码体现
09.07 多态中的成员访问特点
1.成员变量 编译看左边，运行看左边
例:
2.成员方法 编译看左边，运行看右边
例:
3.静态方法 编译看左边，运行看左边(静态方法与类相关，不能算方法的重写)
例:
09.08 多态的好处
多态的好处
提高了程序的维护性(由继承保证)
提高了程序的扩展性(由多态保证)
例:
09.09 多态的弊端
多态的弊端:不能访问子类特有功能
例:
09.10 多态中向上转型和向下转型
例:
运行结果:
向上转型:从子到父，父类引用指向子类对象。例:Fu f = new Zi();
向下转型:从父到子，父类引用转为子类对象。例:Zi z = (Zi)f;
09.11 孔子装爹案例讲解多态现象
多态的问题理解:
09.12 多态继承中的内存图解
09.13 多态中的对象变化内存图解
09.14 猫狗案例多态版
运行结果:
09.15 南北方人案例
运行结果:
09.16 多态的练习题看程序写结果
1.看程序写结果:先判断有没有问题，如果没有，写出结果
运行结果:
2.看程序写结果:先判断有没有问题，如果没有，写出结果
运行结果:
09.17 抽象类的引入
动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。同理，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。
在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
09.18 抽象类的特点
抽象类特点:
1.抽象类和抽象方法必须用abstract关键字修饰
格式: abstract class 类名 {}
public abstract void method();
2.抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
3.抽象类不能实例化，因为抽象类不是具体的，抽象类有构造方法，按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
4.抽象类的子类如果不重写父类中的抽象方法，那么该子类还是抽象类，否则必须重写抽象类中的所有抽象方法
例:
运行结果:
09.19 抽象类的成员特点
成员变量:可以是变量，也可以是常量
构造方法:有构造方法，但是不能实例化，构造方法的作用是用于子类访问父类数据的初始化
成员方法:可以有抽象方法限定子类必须完成某些动作，也可以有非抽象方法提高代码复用性
例:
运行结果:
09.20 抽象类练习猫狗案例
运行结果:
09.21 抽象类练习老师案例
运行结果:
09.22 抽象类练习学员案例
运行结果:
09.23 抽象类练习员工案例
假如我们在开发一个系统时需要对员工类进行设计，员工包含3个属性:姓名、工号以及工资。
经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。
请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。
运行结果:
09.24 抽象类中的小问题
1.一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
可以。不让创建对象。
2.abstract不能和哪些关键字共存
private 冲突
final 冲突
static 无意义
09.25 接口的引入
为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可。
09.26 接口的特点
接口特点:接口用关键字interface表示，格式:interface 接口名 {}
类实现接口用implements表示，格式:class 类名 implements 接口名 {}
接口不能实例化，按照多态的方式，由具体的子类实例化。其实这也是多态的一种，接口多态。
接口的子类要么是抽象类，要么重写接口中的所有抽象方法
09.27 接口的成员特点
成员变量:只能是常量，默认修饰符 public static final
构造方法:没有，因为接口主要是扩展功能的，而没有具体存在
成员方法:只能是抽象方法，默认修饰符 public abstract
09.28 类与类,类与接口,接口与接口的关系
类与类的关系:继承关系，只能单继承，但是可以多层继承
类与接口的关系:实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口
接口与接口的关系:继承关系，可以单继承，也可以多继承
09.29 抽象类和接口的区别
成员区别:
抽象类:成员变量，可以是变量也可以是常量。构造方法，有。成员方法，可以是抽象方法也可以是非抽象方法
接口:成员变量，只可以是常量。构造方法，没有。成员方法，只可以是抽象方法
关系区别:
类与类继承，单继承
类与接口实现，单实现，多实现
接口与接口继承，单继承，多继承
设计理念区别:
抽象类被继承体现的是:”is a”的关系。继承体系的共性功能
接口被实现体现的是:”like a”的关系。继承体系的扩展功能
09.30 猫狗案例加入跳高功能分析
猫狗案例,加入跳高的额外功能
分析:从具体到抽象
猫:姓名,年龄 吃饭，睡觉
狗:姓名,年龄 吃饭，睡觉
由于有共性功能，所以，我们抽取出一个父类:
动物:姓名,年龄 吃饭();睡觉(){}
猫:继承自动物
狗:继承自动物
跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口:跳高
部分猫:实现跳高
部分狗:实现跳高
实现:从抽象到具体
使用:使用具体类
09.31 猫狗案例加入跳高功能代码实现
运行结果:
09.32 老师学生案例加入抽烟功能分析及代码实现
例:
class Fu
{
public final void show()
{
System.out.println("访问底层资源");
}
}
class Zi extends Fu
{
public void show()
{
System.out.println("Zi show run");
}
}
class Demo
{
public static void main(String[] args)
{
Zi z = new Zi();
z.show();
}
}上面的代码中父类中的show()方法如果不想被子类覆盖，可以使用final关键字修饰，当子类覆盖了父类中的show()方法，将会报以下错误:
final关键字是最终的意思，可以修饰类，成员变量，成员方法
09.02 final关键字修饰类,方法以及变量的特点
修饰类，类不能被继承
修饰方法，方法不能被重写
修饰变量，变量就变成了常量，只能被赋值一次
09.03 final关键字修饰局部变量
例:
class Student
{
int age = 10;
}
class Demo
{
public static void main(String[] args)
{
//final修饰基本类型的局部变量
final int x = 10;
//x = 20; 值不能被改变
System.out.println(x);
//final修饰引用类型的局部变量
final Student s = new Student();
//s = new Student(); 引用类型的地址值不能变
s.age = 20;
System.out.println(s.age);
}
}final修饰基本类型的局部变量，该变量的值不能被改变
final修饰引用类型的局部变量，引用类型的地址值不能变
09.04 final修饰变量的初始化时机
例:
class Test
{
int num1;
final int num2; //在对象构造完毕前即可
public Test()
{
num1 = 100;
num2 = 200;
}
}
class Demo
{
public static void main(String[] args)
{
Test t = new Test();
System.out.println(t.num1);
System.out.println(t.num2);
}
}09.05 多态的概述和前提条件
多态概述:某一个对象，在不同时刻表现出来的不同状态。
举例:猫可以是猫的类型。Cat c = new Cat();
同时猫也是动物的一种，也可以把猫称为动物。Animal a = new Animal();
多态的前提:
1.有继承关系
2.有方法重写
3.有父类引用指向子类对象
09.06 按照多态前提给出代码体现
class Fu
{
public void show()
{
System.out.println("Fu show run")
}
}
class Zi extends Fu
{
public void show()
{
System.out.println("Zi show run")
}
}
class Demo
{
public static void main(String[] args)
{
//父类引用指向子类对象
Fu f = new Zi();
}
}09.07 多态中的成员访问特点
1.成员变量 编译看左边，运行看左边
例:
class Fu
{
public int num1 = 10;
}
class Zi extends Fu
{
public int num1 = 20;
public int num2 = 30;
}
class Demo
{
public static void main(String[] args)
{
//编译时查看Fu类中是否有num1，有就编译通过
Fu f = new Zi();
//运行时输出Fu类中的num1
System.out.println(f.num1);
//Fu类中没有num2，编译失败
//System.out.println(f.num2);
}
}2.成员方法 编译看左边，运行看右边
例:
class Fu
{
public void show()
{
System.out.println("Fu show run");
}
}
class Zi extends Fu
{
public void show()
{
System.out.println("Zi show run");
}
public void method()
{
System.out.println("Zi method run");
}
}
class Demo
{
public static void main(String[] args)
{
Fu f = new Zi();
//编译时查看Fu类中是否有show()方法，有就编译通过
//运行时输出Zi类中show()方法
f.show();
//Fu类中没有num2，编译失败
//f.method();
}
}3.静态方法 编译看左边，运行看左边(静态方法与类相关，不能算方法的重写)
例:
class Fu
{
public static void show()
{
System.out.println("Fu show run");
}
}
class Zi extends Fu
{
public static void show()
{
System.out.println("Zi show run");
}
public void method()
{
System.out.println("Zi method run");
}
}
class Demo
{
public static void main(String[] args)
{
Fu f = new Zi();
//编译时查看Fu类中是否有show()方法，有就编译通过
//运行时输出Fu类中show()方法
f.show();
}
}09.08 多态的好处
多态的好处
提高了程序的维护性(由继承保证)
提高了程序的扩展性(由多态保证)
例:
class Animal
{
public void eat()
{
System.out.println("eat");
}
}
class Cat extends Animal
{
public void eat()
{
System.out.println("猫吃鱼");
}
}
class Dog extends Animal
{
public void eat()
{
System.out.println("狗吃肉");
}
}
class Demo
{
public static void main(String[] args)
{
Cat c = new Cat();
Dog d = new Dog();
method(c);
method(d);
}
//提高了代码的扩展性，前期定义的代码可以使用后期的内容
public static void method(Animal a)
{
a.eat();
}
}09.09 多态的弊端
多态的弊端:不能访问子类特有功能
例:
class Fu
{
public void show()
{
System.out.println("Fu show run");
}
}
class Zi extends Fu
{
public void show()
{
System.out.println("Zi show run");
}
public void method()
{
System.out.println("Zi method run");
}
}
class Demo
{
public static void main(String[] args)
{
Fu f = new Zi();
f.show();
//错误，不能访问子类特有功能
//f.method();
}
}09.10 多态中向上转型和向下转型
例:
class Fu
{
public void show()
{
System.out.println("Fu show run");
}
}
class Zi extends Fu
{
public void show()
{
System.out.println("Zi show run");
}
public void method()
{
System.out.println("Zi method run");
}
}
class Demo
{
public static void main(String[] args)
{
Fu f = new Zi();
f.show();
//使用向下转型以使用子类特有方法
Zi z = (Zi)f;
z.method();
}
}运行结果:
Zi show run Zi method run
向上转型:从子到父，父类引用指向子类对象。例:Fu f = new Zi();
向下转型:从父到子，父类引用转为子类对象。例:Zi z = (Zi)f;
09.11 孔子装爹案例讲解多态现象
多态的问题理解:
class 孔子爹
{
public int age = 40;
public void teach()
{
System.out.println("讲解JavaSE");
}
}
class 孔子 extends 孔子爹
{
public int age = 20;
public void teach()
{
System.out.println("讲解论语");
}
public void playGame()
{
System.out.println("英雄联盟");
}
}
//Java培训特别火,很多人来请孔子爹去讲课，这一天孔子爹被请走了
//但是还有人来请，就剩孔子在家，价格还挺高。孔子一想，我是不是可以考虑去呢?
//然后就穿上爹的衣服，带上爹的眼睛，粘上爹的胡子。就开始装爹
//向上转型
孔子爹 k爹 = new 孔子();
//到人家那里去了
System.out.println(k爹.age); //40
k爹.teach(); //讲解论语
//k爹.playGame(); //这是儿子才能做的
//讲完了，下班回家了
//脱下爹的装备，换上自己的装备
//向下转型
孔子 k = (孔子) k爹;
System.out.println(k.age); //20
k.teach(); //讲解论语
k.playGame(); //英雄联盟09.12 多态继承中的内存图解
09.13 多态中的对象变化内存图解
09.14 猫狗案例多态版
class Animal
{
public void eat()
{
System.out.println("吃饭");
}
}
class Cat extends Animal
{
public void eat()
{
System.out.println("猫吃鱼");
}
public void playGame()
{
System.out.println("猫玩游戏");
}
}
class Dog extends Animal
{
public void eat()
{
System.out.println("狗吃肉");
}
public void lookDoor()
{
System.out.println("狗看门");
}
}
class Demo
{
public static void main(String[] args)
{
Animal a = new Dog();
a.eat();
Dog d = (Dog)a;
d.lookDoor();
System.out.println("------");
a = new Cat();
a.eat();
Cat c = (Cat)a;
c.playGame();
}
}运行结果:
狗吃肉 狗看门 ------ 猫吃鱼 猫玩游戏
09.15 南北方人案例
class Person
{
String name;
Person(String name)
{
this.name = name;
System.out.println(name);
}
public void eat()
{
System.out.println("吃饭");
}
}
class SouthPerson extends Person
{
SouthPerson(String name)
{
super(name);
}
public void eat()
{
System.out.println("炒菜,吃米饭");
}
public void jingShang()
{
System.out.println("经商");
}
}
class NorthPerson extends Person
{
NorthPerson(String name)
{
super(name);
}
public void eat()
{
System.out.println("炖菜,吃馒头");
}
public void yanJiu()
{
System.out.println("研究");
}
}
class Demo
{
public static void main(String[] args)
{
//测试
//南方人
Person p = new SouthPerson("南方人");
p.eat();
SouthPerson sp = (SouthPerson)p;
sp.jingShang();
System.out.println("--------");
//北方人
p = new NorthPerson("北方人");
p.eat();
NorthPerson np = (NorthPerson)p;
np.yanJiu();
}
}运行结果:
南方人 炒菜,吃米饭 经商 -------- 北方人 炖菜,吃馒头 研究
09.16 多态的练习题看程序写结果
1.看程序写结果:先判断有没有问题，如果没有，写出结果
class Fu
{
public void show()
{
System.out.println("fu show run");
}
}
class Zi extends Fu
{
public void show()
{
System.out.println("zi show run");
}
public void method()
{
System.out.println("zi method run");
}
}
class Demo
{
public static void main(String[] args)
{
Fu f = new Zi();
//找不到符号
//f.method();
f.show();
}
}运行结果:
zi show run
2.看程序写结果:先判断有没有问题，如果没有，写出结果
class A
{
public void show()
{
show2();
}
public void show2()
{
System.out.println("hello ");
}
}
class B extends A
{
/*
//从父类继承
public void show()
{
show2();
}
*/
public void show2()
{
System.out.println("world ");
}
}
class C extends B
{
public void show()
{
super.show();
}
public void show2()
{
System.out.println("java ");
}
}
class Demo
{
public static void main(String[] args)
{
A a = new B();
a.show();
B b = new C();
b.show();
}
}运行结果:
world java
09.17 抽象类的引入
动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。同理，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。
在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
09.18 抽象类的特点
抽象类特点:
1.抽象类和抽象方法必须用abstract关键字修饰
格式: abstract class 类名 {}
public abstract void method();
2.抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
3.抽象类不能实例化，因为抽象类不是具体的，抽象类有构造方法，按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
4.抽象类的子类如果不重写父类中的抽象方法，那么该子类还是抽象类，否则必须重写抽象类中的所有抽象方法
例:
abstract class Animal
{
public abstract void eat();
}
class Cat extends Animal
{
public void eat()
{
System.out.println("猫吃鱼");
}
}
class Demo
{
public static void main(String[] args)
{
//多态
Animal a = new Cat();
a.eat();
}
}运行结果:
猫吃鱼
09.19 抽象类的成员特点
成员变量:可以是变量，也可以是常量
构造方法:有构造方法，但是不能实例化，构造方法的作用是用于子类访问父类数据的初始化
成员方法:可以有抽象方法限定子类必须完成某些动作，也可以有非抽象方法提高代码复用性
例:
abstract class Animal
{
public int num1 = 10;//变量
public final int num2 = 20;//常量
public Animal(){}//构造函数
public abstract void show();//抽象方法
public void method()//非抽象方法
{
System.out.println("Animal method run");
}
}
class Cat extends Animal
{
public void show()
{
System.out.println("Cat show run");
}
}
class Demo
{
public static void main(String[] args)
{
//创建对象
Animal a = new Cat();
System.out.println(a.num1);//访问变量
System.out.println(a.num2);//访问常量
a.show();//访问抽象方法
a.method();//访问非抽象方法
}
}运行结果:
10 20 Cat show run Animal method run
09.20 抽象类练习猫狗案例
/*
猫狗案例
具体事物:猫，狗
共性:姓名，年龄，吃饭
分析:从具体到抽象
猫:
成员变量:姓名，年龄
构造方法:无参，带参
成员方法:吃饭(猫吃鱼)
狗:
成员变量:姓名，年龄
构造方法:无参，带参
成员方法:吃饭(狗吃肉)
因为有共性的内容，所以就提取了一个父类。动物。
但是又由于吃饭的内容不一样，所以吃饭的方法是抽象的，
而方法是抽象的类，类就必须定义为抽象类。
抽象动物类:
成员变量:姓名，年龄
构造方法:无参，带参
成员方法:吃饭();
实现:从抽象到具体
动物类:
成员变量:姓名，年龄
构造方法:无参，带参
成员方法:吃饭();
狗类:
继承自动物类
重写吃饭();
猫类:
继承自动物类
重写吃饭();
*/
abstract class Animal
{
//姓名
private String name;
//年龄
private int age;
public Animal() {}
public Animal(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 abstract void eat();
}
//定义具体的狗类
class Dog extends Animal
{
public Dog() {}
public Dog(String name,int age)
{
super(name,age);
}
public void eat()
{
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 Demo
{
public static void main(String[] args)
{
//测试狗类，具体类用法 方式1
Dog d = new Dog();
d.setName("旺财");
d.setAge(3);
System.out.println(d.getName()+"---"+d.getAge());
d.eat();
//测试狗类，具体类用法 方式2:
Dog d2 = new Dog("旺财",3);
System.out.println(d2.getName()+"---"+d2.getAge());
d2.eat();
System.out.println("-------------");
//测试狗类，多态用法 方式1:
Animal a = new Dog();
a.setName("旺财");
a.setAge(3);
System.out.println(a.getName()+"---"+a.getAge());
a.eat();
//测试狗类，多态用法 方式2:
Animal a2 = new Dog("旺财",3);
System.out.println(a2.getName()+"---"+a2.getAge());
a2.eat();
}
}运行结果:
旺财---3 狗吃肉 旺财---3 狗吃肉 ------------- 旺财---3 狗吃肉 旺财---3 狗吃肉
09.21 抽象类练习老师案例
/*
老师案例
具体事物:基础班老师，就业班老师
共性:姓名，年龄，讲课。
分析:
基础班老师
姓名，年龄
讲课。
就业班老师
姓名，年龄
讲课。
实现:
老师类
基础班老师
就业班老师
*/
//定义抽象的老师类
abstract class Teacher
{
//姓名
private String name;
//年龄
private int age;
public Teacher() {}
public Teacher(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 abstract void teach();
}
//基础班老师类
class BasicTeacher extends Teacher
{
public BasicTeacher(){}
public BasicTeacher(String name,int age)
{
super(name,age);
}
public void teach()
{
System.out.println("基础班老师讲解JavaSE");
}
}
//就业班老师类
class WorkTeacher extends Teacher
{
public WorkTeacher(){}
public WorkTeacher(String name,int age)
{
super(name,age);
}
public void teach()
{
System.out.println("就业班老师讲解JavaEE");
}
}
class Demo
{
public static void main(String[] args)
{
//多态测试
//基础班老师
Teacher t = new BasicTeacher();
t.setName("小明");
t.setAge(30);
System.out.println(t.getName()+"---"+t.getAge());
t.teach();
System.out.println("--------------------");
t = new BasicTeacher("小明",30);
System.out.println(t.getName()+"---"+t.getAge());
t.teach();
System.out.println("--------------------");
//就业班老师
t = new WorkTeacher();
t.setName("小红");
t.setAge(35);
System.out.println(t.getName()+"---"+t.getAge());
t.teach();
System.out.println("--------------------");
t = new WorkTeacher("小红",35);
System.out.println(t.getName()+"---"+t.getAge());
t.teach();
}
}运行结果:
小明---30 基础班老师讲解JavaSE -------------------- 小明---30 基础班老师讲解JavaSE -------------------- 小红---35 就业班老师讲解JavaEE -------------------- 小红---35 就业班老师讲解JavaEE
09.22 抽象类练习学员案例
/*
学生案例
具体事务:基础班学员，就业班学员
共性:姓名，年龄，班级，学习，吃饭
分析:
基础班学员
成员变量:姓名，年龄，班级
成员方法:学习，吃饭
就业班学员
成员变量:姓名，年龄，班级
成员方法:学习，吃饭
得到一个学员类。
成员变量:姓名，年龄，班级
成员方法:学习，吃饭
实现:
学员类
基础班学员
就业班学员
*/
//定义抽象学员类
abstract class Student
{
//姓名
private String name;
//年龄
private int age;
//班级
private String grand;
public Student() {}
public Student(String name,int age,String grand)
{
this.name = name;
this.age = age;
this.grand = grand;
}
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 String getGrand()
{
return grand;
}
public void setGrand(String grand)
{
this.grand = grand;
}
//学习
public abstract void study();
//吃饭
public void eat()
{
System.out.println("吃饭");
}
}
//具体基础班学员类
class BasicStudent extends Student
{
public BasicStudent() {}
public BasicStudent(String name,int age,String grand)
{
super(name,age,grand);
}
//重写父类抽象方法
public void study()
{
System.out.println("基础班学员学习JavaSE");
}
}
//具体就业班学员类
class WorkStudent extends Student
{
public WorkStudent() {}
public WorkStudent(String name,int age,String grand)
{
super(name,age,grand);
}
//重写父类抽象方法
public void study()
{
System.out.println("就业班学员学习JavaEE");
}
}
class Demo
{
public static void main(String[] args)
{
//按照多态的方式测试基础班学员
Student s = new BasicStudent();
s.setName("小明");
s.setAge(27);
s.setGrand("1111");
System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand());
s.study();
s.eat();
System.out.println("--------------");
s = new BasicStudent("小红",28,"1111");
System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand());
s.study();
s.eat();
}
}运行结果:
小明---27---1111 基础班学员学习JavaSE 吃饭 -------------- 小红---28---1111 基础班学员学习JavaSE 吃饭
09.23 抽象类练习员工案例
假如我们在开发一个系统时需要对员工类进行设计，员工包含3个属性:姓名、工号以及工资。
经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。
请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。
/*
分析:
普通员工类
成员变量:姓名、工号以及工资。
成员方法:工作
经理类:
成员变量:姓名、工号以及工资，奖金属性
成员方法:工作
实现:
员工类:
普通员工类:
经理类:
*/
//定义员工类
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 String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public String getId()
{
return id;
}
public void setId(String id)
{
this.id = id;
}
public int getSalary()
{
return salary;
}
public void setSalary(int salary)
{
this.salary = salary;
}
//工作
public abstract void work();
}
//普通员工类
class Programmer extends Employee
{
public Programmer(){}
public Programmer(String name,String id,int salary)
{
super(name,id,salary);
}
public void work()
{
System.out.println("按照需求写代码");
}
}
//经理类
class Manager extends Employee
{
//奖金
private int money;
public Manager(){}
public Manager(String name,String id,int salary,int money)
{
super(name,id,salary);
this.money = money;
}
public void work()
{
System.out.println("跟客户谈需求");
}
public int getMoney()
{
return money;
}
public void setMoney(int money)
{
this.money = money;
}
}
class Demo
{
public static void main(String[] args)
{
//测试普通员工
Employee emp = new Programmer();
emp.setName("小明");
emp.setId("czbk001");
emp.setSalary(18000);
System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
emp.work();
System.out.println("-------------");
emp = new Programmer("小明","czbk001",18000);
System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
emp.work();
System.out.println("-------------");
//由于子类有特有的内容，所以我们用子类来测试
Manager m = new Manager();
m.setName("小红");
m.setId("czbk002");
m.setSalary(8000);
m.setMoney(2000);
System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
m.work();
System.out.println("-------------");
//通过构造方法赋值
m = new Manager("小红","czbk002",8000,2000);
System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
m.work();
}
}运行结果:
小明---czbk001---18000 按照需求写代码 ------------- 小明---czbk001---18000 按照需求写代码 ------------- 小红---czbk002---8000---2000 跟客户谈需求 ------------- 小红---czbk002---8000---2000 跟客户谈需求
09.24 抽象类中的小问题
1.一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
可以。不让创建对象。
2.abstract不能和哪些关键字共存
private 冲突
final 冲突
static 无意义
09.25 接口的引入
为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可。
09.26 接口的特点
接口特点:接口用关键字interface表示，格式:interface 接口名 {}
类实现接口用implements表示，格式:class 类名 implements 接口名 {}
接口不能实例化，按照多态的方式，由具体的子类实例化。其实这也是多态的一种，接口多态。
接口的子类要么是抽象类，要么重写接口中的所有抽象方法
09.27 接口的成员特点
成员变量:只能是常量，默认修饰符 public static final
构造方法:没有，因为接口主要是扩展功能的，而没有具体存在
成员方法:只能是抽象方法，默认修饰符 public abstract
09.28 类与类,类与接口,接口与接口的关系
类与类的关系:继承关系，只能单继承，但是可以多层继承
类与接口的关系:实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口
接口与接口的关系:继承关系，可以单继承，也可以多继承
09.29 抽象类和接口的区别
成员区别:
抽象类:成员变量，可以是变量也可以是常量。构造方法，有。成员方法，可以是抽象方法也可以是非抽象方法
接口:成员变量，只可以是常量。构造方法，没有。成员方法，只可以是抽象方法
关系区别:
类与类继承，单继承
类与接口实现，单实现，多实现
接口与接口继承，单继承，多继承
设计理念区别:
抽象类被继承体现的是:”is a”的关系。继承体系的共性功能
接口被实现体现的是:”like a”的关系。继承体系的扩展功能
09.30 猫狗案例加入跳高功能分析
猫狗案例,加入跳高的额外功能
分析:从具体到抽象
猫:姓名,年龄 吃饭，睡觉
狗:姓名,年龄 吃饭，睡觉
由于有共性功能，所以，我们抽取出一个父类:
动物:姓名,年龄 吃饭();睡觉(){}
猫:继承自动物
狗:继承自动物
跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口:跳高
部分猫:实现跳高
部分狗:实现跳高
实现:从抽象到具体
使用:使用具体类
09.31 猫狗案例加入跳高功能代码实现
//定义跳高接口
interface Jumpping
{
//跳高功能
public abstract void jump();
}
//定义抽象类
abstract class Animal
{
//姓名
private String name;
//年龄
private int age;
public Animal() {}
public Animal(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 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("跳高狗");
}
}
class Demo
{
public static void main(String[] args)
{
//定义猫并测试
JumpCat jc = new JumpCat();
jc.setName("哆啦A梦");
jc.setAge(3);
System.out.println(jc.getName()+"---"+jc.getAge());
jc.eat();
jc.sleep();
jc.jump();
System.out.println("-----------------");
JumpCat jc2 = new JumpCat("加菲猫",2);
System.out.println(jc2.getName()+"---"+jc2.getAge());
jc2.eat();
jc2.sleep();
jc2.jump();
}
}运行结果:
哆啦A梦---3 猫吃鱼 睡觉 跳高猫 ------------ 加菲猫---2 猫吃鱼 睡觉 跳高猫
09.32 老师学生案例加入抽烟功能分析及代码实现
/*
老师和学生案例,加入抽烟的额外功能
分析:从具体到抽象
老师:姓名，年龄，吃饭，睡觉
学生:姓名，年龄，吃饭，睡觉
由于有共性功能，我们提取出一个父类，人类。
人类:
姓名，年龄
吃饭();
睡觉(){}
抽烟的额外功能不是人或者老师，或者学生一开始就应该具备的，所以，我们把它定义为接口
部分老师抽烟:实现抽烟接口
部分学生抽烟:实现抽烟接口
实现:从抽象到具体
*/
//定义抽烟接口
interface Smoking
{
//抽烟的抽象方法
public abstract void smoke();
}
//定义抽象人类
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 abstract void eat();
//睡觉(){}
public void sleep()
{
System.out.println("睡觉");
}
}
//具体老师类
class Teacher extends Person
{
public Teacher() {}
public Teacher(String name,int age)
{
super(name,age);
}
public void eat()
{
System.out.println("吃大白菜");
}
}
//具体学生类
class Student extends Person
{
public Student() {}
public Student(String name,int age)
{
super(name,age);
}
public void eat()
{
System.out.println("吃红烧肉");
}
}
//抽烟的老师
class SmokingTeacher extends Teacher implements Smoking
{
public SmokingTeacher() {}
public SmokingTeacher(String name,int age)
{
super(name,age);
}
public void smoke()
{
System.out.println("抽烟的老师");
}
}
//抽烟的学生
class SmokingStudent extends Student implements Smoking
{
public SmokingStudent() {}
public SmokingStudent(String name,int age)
{
super(name,age);
}
public void smoke()
{
System.out.println("抽烟的学生");
}
}
class Demo
{
public static void main(String[] args)
{
//测试学生
SmokingStudent ss = new SmokingStudent();
ss.setName("小明");
ss.setAge(27);
System.out.println(ss.getName()+"---"+ss.getAge());
ss.eat();
ss.sleep();
ss.smoke();
System.out.println("------------");
SmokingStudent ss2 = new SmokingStudent("小强",30);
System.out.println(ss2.getName()+"---"+ss2.getAge());
ss2.eat();
ss2.sleep();
ss2.smoke();
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- JavaSE学习总结第08天_面向对象3
- JavaSE学习总结第10天_面向对象5
- JavaSE视频学习阶段性总结 二（流程控制，面向对象，封装）
- JavaSE学习总结第06天_Java语言基础2 & 面向对象1
- JAVASE总结--06（面向过程、面向对象、内存分析）
- JavaSe总结-07--面向对象(2)
- JavaSE学习总结第07天_面向对象2
- java基础学习总结——面向对象1
- java基础学习_面向对象(上)01_day07总结
- <JavaSE学习笔记>面向对象（2）：Java内存机制
- java基础学习总结--面向对象
- JavaSE学习总结第22天_IO流4
- JavaSE学习总结第24天_多线程2
- java基础学习_面向对象(下)02_day09总结
- java基础----面向对象5(关键字的总结学习)
- 学习面向对象的一些总结
- 【JavaSE学习笔记】面向对象_多态、抽象
- JavaSE学习总结第13天_API常用对象3
- 【JavaSE学习笔记】面向对象_接口、形式参数问题、内部类
- Java基础学习总结——面向对象