网站动态画面用啥做,抖音分享小程序怎么赚钱,泰州网站建设价位,电话用网站做综合布线今天接着学习多态和继承 目录 1 继承1.1 再谈初始化1.2 protect关键字1.3 继承方式1.4 final 关键字1.5 组合 2 多态2.1 多态的概念2.2 多态实现条件2.3 重写2.4 向上转型和向下转型2.4.1 向上转型2.4.2 向下转型 2.5 多态的优缺点2.6 避免在构造方法中使用重写的方法 总结 1 继…今天接着学习多态和继承 目录 1 继承1.1 再谈初始化1.2 protect关键字1.3 继承方式1.4 final 关键字1.5 组合 2 多态2.1 多态的概念2.2 多态实现条件2.3 重写2.4 向上转型和向下转型2.4.1 向上转型2.4.2 向下转型 2.5 多态的优缺点2.6 避免在构造方法中使用重写的方法 总结 1 继承
1.1 再谈初始化
我们简单回顾一下几个重要的代码块 实例代码块和静态代码块。在没有继承关系时的执行顺序。
class Person {public String name;public int age;public Person(String name, int age) {this.name name;this.age age;System.out.println(构造方法执行);}{System.out.println(实例代码块执行);}static {System.out.println(静态代码块执行);}
}public static class TestDemo {public static void main(String[] args) {Person person1 new Person(xiaoxin,10);System.out.println();Person person2 new Person(hyzs,20);}
}静态代码块先执行并且只执行一次在类加载阶段执行当有对象创建时才会执行实例代码块 实例代码块执行完成后最后构造方法执行
class Person {public String name;public int age;public Person(String name, int age) {this.name name;this.age age;System.out.println(Person构造方法执行);}{System.out.println(Person实例代码块执行);}static {System.out.println(Person静态代码块执行);}
}class Student extends Person{public Student(String name,int age) {super(name,age);System.out.println(Student构造方法执行);}{System.out.println(Student实例代码块执行);}static {System.out.println(Student静态代码块执行);}
}public class TestDemo4 {public static void main(String[] args) {Student student1 new Student(xiaoxin1,19);System.out.println();Student student2 new Student(hyzs,20);}public static void main1(String[] args) {Person person1 new Person(xiaoxin2,10);System.out.println();Person person2 new Person(hyzs,20);}
}Person静态代码块执行 Student静态代码块执行 Person实例代码块执行 Person构造方法执行 Student实例代码块执行 Student构造方法执行 Person实例代码块执行 Person构造方法执行 Student实例代码块执行 Student构造方法执行 通过分析执行结果得出以下结论 1、父类静态代码块优先于子类静态代码块执行且是最早执行 2、父类实例代码块和父类构造方法紧接着执行 3、子类的实例代码块和子类构造方法紧接着再执行 4、第二次实例化子类对象时 父类和子类的静态代码块都将不会再执行
1.2 protect关键字
Java中引入了访问限定符 主要限定类或者类中成员能否在类外或者其他包中被访问 那父类中不同访问权限的成员 在子类中的可见性又是什么样子的呢
// 为了掩饰基类中不同访问权限在子类中的可见性为了简单类B中就不设置成员方法了
// extend01包中
public class B {private int a;protected int b;public int c;int d;
}// extend01包中
// 同一个包中的子类
public class D extends B{public void method(){// super.a 10; // 编译报错父类private成员在相同包子类中不可见super.b 20; // 父类中protected成员在相同包子类中可以直接访问super.c 30; // 父类中public成员在相同包子类中可以直接访问super.d 40; // 父类中默认访问权限修饰的成员在相同包子类中可以直接访问}
}// extend02包中
// 不同包中的子类
public class C extends B {public void method(){// super.a 10; // 编译报错父类中private成员在不同包子类中不可见super.b 20; // 父类中protected修饰的成员在不同包子类中可以直接访问super.c 30; // 父类中public修饰的成员在不同包子类中可以直接访问//super.d 40; // 父类中默认访问权限修饰的成员在不同包子类中不能直接访问}
}// extend02包中
// 不同包中的类
public class TestC {public static void main(String[] args) {C c new C();c.method();// System.out.println(c.a); // 编译报错父类中private成员在不同包其他类中不可见// System.out.println(c.b); // 父类中protected成员在不同包其他类中不能直接访问System.out.println(c.c); // 父类中public成员在不同包其他类中可以直接访问// System.out.println(c.d); // 父类中默认访问权限修饰的成员在不同包其他类中不能直接访问}
}注意父类中private成员变量虽然在子类中不能直接访问 但是也继承到子类中了
1.3 继承方式
在现实生活中事物之间的关系是非常复杂灵活多样 但在Java中只支持以下几种继承方式 注意Java中不支持多继承
1.4 final 关键字
final关键可以用来修饰变量、成员方法以及类
修饰变量或字段表示常量(即不能修改)
final int a 10;
a 20; // 编译出错修饰类表示此类不能被继承
final public class Animal {...
}
public class Bird extends Animal {...
}
// 编译出错
Error:(3, 27) java: 无法从最终com.bit.Animal进行继承修饰方法表示该方法不能被重写(后续介绍)
1.5 组合
和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果。 组合并没有涉及到特殊的语法(诸如 extends 这样的关键字), 仅仅是将一个类的实例作为另外一个类的字段。
继承表示对象之间是is-a的关系比如狗是动物猫是动物 组合表示对象之间是has-a的关系比如汽车 汽车和其轮胎、发动机、方向盘、车载系统等的关系 就应该是组合因为汽车是由这些部件组成的
// 轮胎类
class Tire{// ...
}
// 发动机类
class Engine{// ...
}
// 车载系统类
class VehicleSystem{// ...
}
class Car{private Tire tire; // 可以复用轮胎中的属性和方法private Engine engine; // 可以复用发动机中的属性和方法private VehicleSystem vs; // 可以复用车载系统中的属性和方法// ...
}
// 奔驰是汽车
class Benz extend Car{// 将汽车中包含的轮胎、发送机、车载系统全部继承下来
}组合和继承都可以实现代码复用应该使用继承还是组合 需要根据应用场景来选择一般建议能用组合尽量用组合
2 多态
2.1 多态的概念
多态的概念通俗来说就是多种形态 具体点就是去完成某个行为 当不同的对象去完成时会产生出不同 的状态 总的来说同一件事情 发生在不同对象身上就会产生不同的结果
2.2 多态实现条件
在java中要实现多态必须要满足如下几个条件缺一不可
必须在继承体系下子类必须要对父类中方法进行重写通过父类的引用调用重写的方法 多态体现在代码运行时当传递不同类对象时 会调用对应类中的方法。
public class Animal {String name;int age;public Animal(String name, int age){this.name name;this.age age;}public void eat(){System.out.println(name 吃饭);}}public class Cat extends Animal{public Cat(String name, int age){super(name, age);}Overridepublic void eat(){System.out.println(name吃鱼~~~);}}public class Dog extends Animal {public Dog(String name, int age){super(name, age);}Overridepublic void eat(){System.out.println(name吃骨头~~~);}
}///分割线//
public class TestAnimal {// 编译器在编译代码时并不知道要调用Dog 还是 Cat 中eat的方法// 等程序运行起来后形参a引用的具体对象确定后才知道调用那个方法// 注意此处的形参类型必须时父类类型才可以public static void eat(Animal a){a.eat();}public static void main(String[] args) {Cat cat new Cat(元宝,2);Dog dog new Dog(小七, 1);eat(cat);eat(dog);}
}运行结果
元宝吃鱼~~~
元宝正在睡觉
小七吃骨头~~~
小七正在睡觉2.3 重写
重写(override)也称为覆盖。 重写是子类对父类非静态、非private修饰非final修饰 非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变核心重写 重写的好处在于子类可以根据需要定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法
子类在重写父类的方法时一般必须与父类方法原型一致 返回值类型 方法名 (参数列表) 要完全一致被重写的方法返回值类型可以不同 但是必须是具有父子关系的访问权限不能比父类中被重写的方法的访问权限更低。 例如如果父类方法被public修饰 则子类中重写该方法就不能声明为 protected父类被static、private修饰的方法、构造方法都不能被重写。重写的方法, 可以使用 Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错,提示无法构成重写. 方法重载是一个类的多态性表现, 而方法重写是子类与父类的一种多态性表现 对于已经投入使用的类尽量不要进行修改。 最好的方式是重新定义一个新的类 来重复利用其中共性的内容并且添加或者改动新的内容
静态绑定也称为前期绑定(早绑定)即在编译时 根据用户所传递实参类型就确定了具体调用那个方法。 典型代表函数重载。 动态绑定也称为后期绑定(晚绑定)即在编译时 不能确定方法的行为需要等到程序运行时 才能够确定具体调用那个类的方法
2.4 向上转型和向下转型
2.4.1 向上转型
向上转型实际就是创建一个子类对象 将其当成父类对象来使用。 语法格式父类类型 对象名 new 子类类型()
Animal animal new Cat(元宝,2);animal是父类类型但可以引用一个子类对象 因为是从小范围向大范围的转换 直接赋值方法传参方法返回
public class TestAnimal {// 2. 方法传参形参为父类型引用可以接收任意子类的对象public static void eatFood(Animal a){a.eat();}// 3. 作返回值返回任意子类对象public static Animal buyAnimal(String var){if(狗.equals(var) ){return new Dog(狗狗,1);}else if(猫 .equals(var)){return new Cat(猫猫, 1);}else{return null;}}public static void main(String[] args) {Animal cat new Cat(元宝,2); // 1. 直接赋值子类对象赋值给父类对象Dog dog new Dog(小七, 1);eatFood(cat);eatFood(dog);Animal animal buyAnimal(狗);animal.eat();animal buyAnimal(猫);animal.eat();}}向上转型的优点让代码实现更简单灵活。 向上转型的缺陷不能调用到子类特有的方法。
2.4.2 向下转型
将一个子类对象经过向上转型之后当成父类方法使用 再无法调用子类的方法但有时候可能需要调用子类特有的方法此时将父类引用再还原为子类对象即可即向下转换
public class TestAnimal {public static void main(String[] args) {Cat cat new Cat(元宝,2);Dog dog new Dog(小七, 1);// 向上转型Animal animal cat;animal.eat();animal dog;animal.eat();// 编译失败编译时编译器将animal当成Animal对象处理// 而Animal类中没有bark方法因此编译失败// animal.bark();// 向上转型// 程序可以通过编程但运行时抛出异常---因为animal实际指向的是狗// 现在要强制还原为猫无法正常还原运行时抛出ClassCastExceptioncat (Cat)animal;cat.mew();// animal本来指向的就是狗因此将animal还原为狗也是安全的 dog (Dog)animal;dog.bark();}
}向下转型用的比较少而且不安全 万一转换失败运行时就会抛异常。 Java中为了提高向下转型的安全性引入了 instanceof 如果该表达式为true则可以安全转换
public class TestAnimal {public static void main(String[] args) {Cat cat new Cat(元宝,2);Dog dog new Dog(小七, 1);// 向上转型Animal animal cat;animal.eat();animal dog;animal.eat();if(animal instanceof Cat){cat (Cat)animal;cat.mew();}if(animal instanceof Dog){dog (Dog)animal;dog.bark();}}
}instanceof 关键词官方介绍instanceof 关键词官方介绍
2.5 多态的优缺点
class Shape {//属性....public void draw() {System.out.println(画图形);}
}class Rect extends Shape{Overridepublic void draw() {System.out.println(♦);}
}class Cycle extends Shape{Overridepublic void draw() {System.out.println(●);}
}class Flower extends Shape{Overridepublic void draw() {System.out.println(❀);}
}能够降低代码的 “圈复杂度”, 避免使用大量的 if - else
什么叫 “圈复杂度” ? 圈复杂度是一种描述一段代码复杂程度的方式. 一段代码如果平铺直叙, 那么就比较简单容易理解. 而如果有很多的条件分支或者循环语句, 就认为理解起来更复杂. 因此我们可以简单粗暴的计算一段代码中条件语句和循环语句出现的个数, 这个个数就称为 “圈复杂度”. 如果一个方法的圈复杂度太高, 就需要考虑重构. 不同公司对于代码的圈复杂度的规范不一样. 一般不会超过 10 .
例如我们现在需要打印的不是一个形状了, 而是多个形状. 如果不基于多态, 实现代码如下:
public static void drawShapes() {Rect rect new Rect();Cycle cycle new Cycle();Flower flower new Flower();String[] shapes {cycle, rect, cycle, rect, flower};for (String shape : shapes) {if (shape.equals(cycle)) {cycle.draw();} else if (shape.equals(rect)) {rect.draw();} else if (shape.equals(flower)) {flower.draw();}}
}如果使用使用多态, 则不必写这么多的 if - else 分支语句, 代码更简单
public static void drawShapes() {// 我们创建了一个 Shape 对象的数组.Shape[] shapes {new Cycle(), new Rect(), new Cycle(),new Rect(), new Flower()};for (Shape shape : shapes) {shape.draw();}
}可扩展能力更强 如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低.
class Triangle extends Shape {Overridepublic void draw() {System.out.println(△);}
}对于类的调用者来说(drawShapes方法), 只要创建一个新类的实例就可以了, 改动成本很低. 而对于不用多态的情况, 就要把 drawShapes 中的 if - else 进行一定的修改, 改动成本更高.
多态缺陷代码的运行效率降低。
属性没有多态性 当父类和子类都有同名属性的时候通过父类引用 只能引用父类自己的成员属性构造方法没有多态性
2.6 避免在构造方法中使用重写的方法
一段有坑的代码. 我们创建两个类, B 是父类, D 是子类. D 中重写 func 方法. 并且在 B 的构造方法中调用 func
class B {public B() {// do nothingfunc();}public void func() {System.out.println(B.func());}
}
class D extends B {private int num 1;Overridepublic void func() {System.out.println(D.func() num);}
}
public class Test {public static void main(String[] args) {D d new D();}
}
// 执行结果
D.func() 0构造 D 对象的同时, 会调用 B 的构造方法. B 的构造方法中调用了 func 方法, 此时会触发动态绑定, 会调用到 D 中的 func 此时 D 对象自身还没有构造, 此时 num 处在未初始化的状态, 值为 0. 如果具备多态性num的值应该是1. 所以在构造函数内尽量避免使用实例方法 除了final和private方法。
结论: “用尽量简单的方式使对象进入可工作状态”, 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题.
总结
今天对继承和多态的学习就先到这里了如果感觉不错希望可以给博主点赞收藏和关注感谢大家的支持还有什么问题和建议可以在评论区评论拜拜。
总结
