——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——-
/*
程序中的多态
父类的引用 = 自己的子类的对象
*/
class Fu
{
public void show(){
System.out.println("父类的show");
}
}
class Zi extends Fu
{
public void show(){
System.out.println("子类重写show");
}
}
class Zi1 extends Fu
{
public void show(){
System.out.println("子类重写show1111");
}
}
class DuoTaiDemo
{
public static void main(String[] args)
{
Fu f = new Zi();
f.show();
//. System.out.println("Hello World!");
}
}
/*
多态中,子类父类中成员访问的特点
*/
class Fu
{
int i = 3;
public static void show(){
System.out.println("父类..show");
}
}
class Zi extends Fu
{
int i = 4;
public static void show(){
System.out.println("子类..show");
}
}
class DuoTaiDemo1
{
public static void main(String[] args)
{
//多态形式进行调用
Fu f = new Zi();
f.show();
//System.out.println(f.i);
}
}
A:案例演示
Cat c = (Cat)a;向下转型
Cat c = new Cat();
B: 多态转型中的类型判断 instanceof运算符
java.lang.ClassCastException 类型转换异常
案例:将Dog对象,强制转成了Cat
关键字,也是运算符 instanceof 运算结果是布尔类型
检查 引用变量是不是这个类创建的
Animal a = new Dog();
Cat c = (Cat)a;
instanceof 判断出变量a 是不狗类创建的对象
固定格式:
引用变量 instanceof 类
a instanceof Dog 判断a 是不是狗类对象,如果是运算符返回true
写在if语句中
使用子类特有功能,需要强制转换,保证安全,使用instanceof判断
C: 多态的设计原理
为什么多态中,有的走父类,有的走子类
编译为什么看左边 Fu f = new Zi();
编译期间特点,检查语法问题,变量没有值,对象也是不存在
编译的时候,看见左边的类类型变量,看不到对象具体是谁
除了非静态的成员方法以外,运行时期,JVM静态的绑定在父类的引用中
但是如果运行的是非静态成员方法,运行时期,JVM动态绑定在子类的对象中,会调用子类的重写方法
为什么,必须运行子类重写方法,设计的原因,扩展父类
子类重写父类方法,目的就为了沿袭父类功能,扩展自己的功能
后面知识点 抽象类,接口,方法是没有主体
public abstract void aa(); 这样的方法根本不能运行
抽象的方法,没有主体的,没有大括号的方法,只能依赖子类重写
/*
孔O装爹案例
有2个事物,一个是孔O,他爹
他爹:
年龄:70
讲学功能:经商
孔O:
年龄:40
讲学功能:论语
玩游戏: 和徒弟一起丢手绢
有人找孔O爹,讲学,但是没找到,孔O在家,
化妆成他爹,去讲学。
你的年龄:70
回家,徒弟找他玩游戏,
卸妆变回他自己,打游戏
*/
class KongZiDie
{
int age = 70;
public void teacher(){
System.out.println("经商");
}
}
class KongZi extends KongZiDie
{
int age = 40;
public void teacher(){
System.out.println("论语");
}
public void playGame(){
System.out.println("打游戏");
}
}
class DuoTaiDemo2
{
public static void main(String[] args)
{
//有人找孔O爹,讲学,但是没找到,孔O在家,
//化妆成他爹,去讲学。
KongZiDie k = new KongZi();//孔O提升为了父类类型
k.teacher();
System.out.println(k.age);
//使用打游戏功能,不可以,是子类特有功能,多态弊端
//k.playGame();
//孔O卸妆,由孔O爹变成孔O,大转向为小的,强制转换
//目标类型 变量 = (目标类型)被转数据
KongZi z = (KongZi)k;
z.playGame();
}
}
class Fu {
public void show() {
System.out.println("fu show");
}
}
class Zi extends Fu {
public void show() {
System.out.println("zi show");
}
public void method() {
System.out.println("zi method");
}
}
class Test1Demo {
public static void main(String[] args) {
Fu f = new Zi();
f.method();//错误,父类未定义method()方法//The method method() is undefined for the type Fu
f.show();
}
}
class A {
public void show() {
show2();
}
public void show2() {
System.out.println("我");
}
}
class B extends A {
public void show2() {
System.out.println("爱");
}
}
class C extends B {
public void show() {
super.show();
}
public void show2() {
System.out.println("你");
}
}
public class Test2DuoTai {
public static void main(String[] args) {
A a = new B();
a.show();
B b = new C();
b.show();
}
}//爱
你
/*
定义抽象类
定义抽象方法
*/
abstract class Abstract
{
public abstract void show();
}
//定义子类继承抽象类,重写抽象方法,建立子类的对象
class SubAbstract extends Abstract
{
//重写抽象方法,去掉修饰符abstract,加上方法体
public void show(){
System.out.println("重写抽象方法");
}
}
class AbstractClassDemo
{
public static void main(String[] args)
{
//创建抽象类的子类对象
SubAbstract sub = new SubAbstract();
sub.show();
//写成多态调用
Abstract a = new SubAbstract();
a.show();
//System.out.println("Hello World!");
}
}
abstract class Abstract
{
Abstract(){
super();
}
public static int i = 1;
public void show(){}
public abstract void function();
public static void haha(){
System.out.println("hahahah");
}
}
class AbstractClassDemo1
{
public static void main(String[] args)
{
Abstract.haha();
System.out.println(Abstract.i);
}
}
abstract class Abstract
{
public final void show(){System.out.println("Hello World!");}
public void haha(){}
}
class SubAbstract extends Abstract
{
}
class AbstractClassDemo2
{
public static void main(String[] args)
{
new SubAbstract().show();
// System.out.println("Hello World!");
}
}
/*
具体事物:猫,狗
共性:姓名,年龄,吃饭
抽象类存在意义:强制子类重写抽象方法
抽象类,是整个继承体系的最顶层类,里面功能所有小弟都具备的
抽象类保证继承体系的完整性
猫:存在的时候,应该具有姓名和年龄
创建对象的时候,猫必须具有姓名和年龄,创建对象赋值成员变量,使用构造器
*/
abstract class Animal
{
private String name;
private int age;
Animal(String name,int age){
this.name = name;
this.age = 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;
}
public abstract void eat();
}
class Cat extends Animal
{
Cat(String name,int age){
//super调用父类构造器,完成成员变量赋值
super(name,age);
}
public void eat(){
System.out.println("猫吃猫粮"+getName()+"..."+getAge());
}
}
class Dog extends Animal
{
Dog(String name,int age){
super(name,age);
}
public void eat(){
System.out.println("狗啃骨头"+getName()+"..."+getAge());
}
}
class AbstractTest
{
public static void main(String[] args)
{
Animal c = new Cat("小白",1);
c.eat();
//修改猫名字和年龄 set
c.setName("机器猫");
c.setAge(2);
c.eat();
System.out.println(c.getName()+"..."+c.getAge());
}
}
/*
具体事物:基础班老师,就业班老师
共性:姓名,年龄,讲课。
*/
//将老师共性内容抽取,一个父类
abstract class Teacher
{
private String name;
private int age;
Teacher(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name){this.name=name;}
public void setAge(int age){this.age=age;}
public String getName(){return name;}
public int getAge(){return age;}
public abstract void teacher();
}
//定义基础老师,姓名年龄,讲课功能
class BaseTeacher extends Teacher
{
BaseTeacher(String name,int age){super(name,age);}
public void teacher(){
System.out.println("JAVA基础SE");
}
}
//定义就业班老师,姓名年龄,讲课功能
class AdvancedTeacher extends Teacher
{
AdvancedTeacher(String name,int age){super(name,age);}
public void teacher(){
System.out.println("JAVA企业班EE");
}
}
//定义就业辅导老师,姓名年龄,讲课功能
class JobTeacher extends Teacher
{
JobTeacher(String name,int age){super(name,age);}
public void teacher(){
System.out.println("面试技巧");
}
}
class AbstractTest1
{
public static void main(String[] args)
{
//多态形式调用老师的功能
/*Teacher t = new BaseTeacher("张三",101);
t.teacher();
System.out.println(t.getName()+"..."+t.getAge());
t = new AdvancedTeacher("李四",29);
t.teacher();
System.out.println(t.getName()+"..."+t.getAge());
t = new JobTeacher("王五",44);
t.teacher();
System.out.println(t.getName()+"..."+t.getAge());*/
//调用teacher传递Teacher的子类对象
teacher(new BaseTeacher("张三",100));
teacher(new BaseTeacher("张三丰",30));
}
//定义方法,将main重复代码抽取方法
public static void teacher(Teacher t){
t.teacher();
System.out.println(t.getName()+"..."+t.getAge());
}
}
/*
员工与经理
继承思想,共性抽取
采用两种方法创建子类对象
先创建子类对象,调用set方法赋值
再来一种,创建子类对象同时赋值变量
*/
//共性抽取,奖金不能动
abstract class Company
{
private String name;
private String id;
private double money;
Company(){}
Company(String name,String id,double money){
this.name = name;
this.id = id;
this.money = money;
}
public void setName(String name){this.name=name;}
public void setId(String id){this.id=id;}
public void setMoney(double money){this.money=money;}
public String getName(){return name;}
public String getId(){return id;}
public double getMoney(){return money;}
public abstract void work();
}
//定义员工类
class Employee extends Company
{
Employee(){}
public void work(){
System.out.println("员工在写代码");
}
}
//定义经理类
class Manager extends Company
{
Manager(String name,String id,double money,double bonus){
super(name,id,money);
this.bonus = bonus;
}
private double bonus;
public void setBonus(double bonus){this.bonus=bonus;}
public double getBonus(){return bonus;}
public void work(){
System.out.println("经理指挥你写代码");
}
}
class AbstractTest2
{
public static void main(String[] args)
{
//创建员工类对象,调用set方法赋值
Company e = new Employee();
e.setName("张三");
e.setId("研发部001");
e.setMoney(10000.01);
e.work();
System.out.println(e.getName()+".."+e.getId()+".."+e.getMoney());
//创建经理类对象,构造方法直接赋值
e = new Manager("李四","董事会001",1234.56,567890.98);
e.work();
Manager m = (Manager)e;
System.out.println(e.getName()+".."+e.getId()+".."+e.getMoney()+".."+m.getBonus());
}
}
修饰符的冲突问题
final 抽象目的,子类重写,final不能重写
private 抽象目的,子类重写,但是子类不知道父类有这个方法
static 静态方法类名直接调用,如果是抽象没有方法体,怎么调用
B:接口特点
接口降低程序的耦合性(紧密连接),提高扩展性
面向接口编程
/*
定义接口,关键字interface
注意:修饰符,可写,不写,也可以选择性书写,任意写一个都行
编译的时候定义的是interface 编译器,检查,少哪一个,补充哪一个
*/
interface Inter
{
//定义接口成员变量
public static final int I = 10;
//定义接口成员方法,全抽象
public abstract void show();
}
class InterFaceDemo
{
public static void main(String[] args)
{
System.out.println();
}
}
/*
定义接口,定义实现类,实现接口
创建实现类的对象
*/
interface Inter
{
public static final int I = 3 ;
public abstract void show();
public abstract void show2();
}
//定义接口实现类,实现接口重写抽象方法
class InterImpl implements Inter
{
public void show(){
System.out.println("实现类重写方法");
}
}
class InterFaceDemo
{
public static void main(String[] args)
{
InterImpl impl = new InterImpl();
impl.show();
System.out.println(Inter.I); //常见调用方式
System.out.println(InterImpl.I);
System.out.println(impl.I);
}
}
/*
接口的多实现
一个类,同时实现多个接口
多实现没有安全隐患的
但是方法没有主体,怎么运行,实现什么功能,完全由实现类自己说了算
*/
interface A
{
public abstract void a();
}
interface B
{
public abstract void a();
}
abstract class C
{
public abstract void c();
}
class D extends C implements A,B
{
public void a(){}
public void c(){}
}
class InterFaceDemo2
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
/*
接口之间的多继承关系
*/
interface A
{
void a();
}
interface B
{
void b();
}
interface C extends A,B
{
void c();
}
class D implements C
{
public void a(){}
public void b(){}
public void c(){}
}
class InterFaceDemo3
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
A:成员区别
B:关系区别
C:设计理念区别
/*所有的东西都加上。(分析,实现,测试)
人类:姓名,年龄,吃饭,睡觉。
吸烟接口:吸烟
老师继承人类
学生继承人类
部分老师继承人类并实现吸烟接口
部分学生继承人类并实现吸烟接口
具体的事物
人: 属性成员变量,姓名年龄
人: 行为功能方法,吃饭睡觉
老师:属于人的一种,具备人的特性,继承人
老师的姓名和年龄,需要使用父类方法赋值
自己的特点,上课成功
老师:扩展出来的功能,吸烟
学生:属于人的一种,具备人的特性,继承人
学生自己的姓名和年龄,需要使用父类方法赋值
自己的功能学习
学生:扩展出来的,吸烟
is a 老师和学生是人类中的一种
like a 老师和学生是人类中的一致,但是看上去更像烟民
*/
/*
定义人的抽象类
*/
abstract class Person
{
private String name;
private int age;
Person(){}
Person(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name){this.name=name;}
public void setAge(int age){this.age=age;}
public String getName(){return name;}
public int getAge(){return age;}
//人类具备功能,吃饭,睡觉,写成抽象,子类实现,还是写好,子类调用
public abstract void eat();
public abstract void sleep();
}
/*
定义吸烟接口,谁吸烟,谁实现
*/
interface Smoking
{
public abstract void smoking();
}
//定义老师类,继承Person
class Teacher extends Person
{
//定义空参数构造
Teacher(){}
Teacher(String name,int age){
super(name,age);
}
//继承重写功能
public void eat(){
System.out.println("老师在吃饭");
}
public void sleep(){
System.out.println("老师在睡觉");
}
public void teacher(){
System.out.println("老师在上课");
}
}
//定义吸烟的老师,是人类一种,还吸烟
class SmokingTeacher extends Person implements Smoking
{
SmokingTeacher(){}
SmokingTeacher(String name,int age){
super(name,age);
}
public void eat(){
System.out.println("吸烟的老师在吃饭");
}
public void sleep(){
System.out.println("吸烟的老师在睡觉");
}
public void teacher(){
System.out.println("吸烟的老师在上课");
}
public void smoking(){
System.out.println("老师下课在抽烟");
}
}
class InterFaceTest
{
public static void main(String[] args)
{
Teacher t1 = new Teacher();
t1.setName("张三");
t1.setAge(35);
t1.eat();
t1.sleep();
t1.teacher();
System.out.println(t1.getName()+"..."+t1.getAge());
Teacher t2 = new Teacher("李四",43);
t2.eat();
t2.sleep();
t2.teacher();
System.out.println(t2.getName()+"..."+t2.getAge());
SmokingTeacher st1 = new SmokingTeacher("王五",20);
st1.eat();
st1.sleep();
st1.teacher();
st1.smoking();
System.out.println(st1.getName()+"..."+st1.getAge());
}
}