一*继承:
1.1概念:
继承是面向对象程序设计使得代码可以重复使用的重要手段,它使得在保持原有类的特性的基础上进行扩展,增加新的功能,这样产生新的类,也称派生类。继承呈现了面向对象程序设计的层次结构,体现了从简单到复杂的认知过程。主要解决的问题:共性的抽取,实现代码的复用。
1.2语法:
在java中如果要表示类与类之间的关系,需要使用extends关键字。
基本结构为:
访问修饰符 class 子类 extends 父类{
}
例1:子类继承父类
class Animal{ //Animal是父类
String name;
int age;
public void eat(){
System.out.println(name+"正在吃饭!");
}
public void sleep(){
System.out.println(name+"正在睡觉!");
}
}
class Dog extends Animal{ //Dog是子类 继承了Animal父类中的类成员
String color;
public void bark(){
System.out.println(name+"正在汪汪汪!");
}
}
class Cat extends Animal{ //Cat是子类 继承了Animal父类中的类成员
public void bark(){
System.out.println(name+"正在喵喵喵!");
}
}
public class Test1 {
public static void main(String[] args) {
Dog dog=new Dog();
dog.name="小狗";
dog.age=2;
dog.color="黄色";
dog.bark();
dog.eat();
dog.sleep();
}
}
注意:
1.子类将父类中的成员变量和成员方法都会继承到子类中。
2.子类继承父类后,必须要添加自己特有的成员(特别的成员变量或者成员方法),体现与基类的不同,否则就没有必要继承。
1.3父类成员的访问:
1.3.1子类中访问父类的成员变量:
例2:访问不同名的成员变量
class A{
int a=10;
int b=11;
int c=12;
}
class B extends A{
int d;
public void methodB(){
System.out.println(a);//访问父类继承下来的a
System.out.println(b);//访问父类继承下来的b
System.out.println(c);//访问父类继承下来的c
System.out.println(d);//访问子类自己的d
}
}
public class Test2 {
public static void main(String[] args) {
B b=new B();
b.methodB();
}
}
例3:访问同名的成员变量
class C{
int a=10;
int b=11;
int c;
}
class D extends C{
int a=1;
int b=2;
public void methodD(){
System.out.println(a);//存在同名变量a,优先访问子类的
System.out.println(b);//存在同名变量b,优先访问子类的
System.out.println(c);//访问父类继承下来的d
System.out.println(e);//编译报错
}
}
public class Test3 {
public static void main(String[] args) {
D d=new D();
d.methodD();
}
}
在子类方法中或者通过子类对象访问成员时:
1.如果访问的成员变量子类中有,优先访问自己的成员变量。
2.如果访问的成员变量子类中无,则访问父类继承下来的,如果父类也没有,则编译报错。
3.如果访问的成员变量与父类中成员变量同名,优先访问自己的。
1.3.1子类中访问父类的成员方法:
例4:访问不同名的成员方法
class E {
public void methodE(){
System.out.println("E类中的methodE");
}
}
class F extends E{
public void methodF(){
System.out.println("F类中的methodF");
}
public void methodG(){
methodE();//访问父类继承下来的methodE()
methodF();//访问子类自己的methodF()
}
}
public class Test4 {
public static void main(String[] args) {
F f=new F();
f.methodG();
}
}
例5:访问同名的成员方法
class Demo{
public void method1(){
System.out.println("Demo类中的method1");
}
public void method2(){
System.out.println("Demo类中的method2");
}
}
class Demo1 extends Demo{
public void method1(){
System.out.println("Demo1类中的method1");
}
public void method2(int a){
System.out.println("Demo1类中的method2(int)");
}
public void method3(){
method1();//访问的是子类中的method1
method2();//访问的是父类继承下来的method2
method2(10);//访问的是子类中的method2(int)
}
}
public class Test5 {
public static void main(String[] args) {
Demo1 demo1=new Demo1();
demo1.method3();
}
}
在子类方法中或者通过子类对象访问成员时:
1.成员方法没有同名时,则优先访问自己的,自己没有时再到父类中找,如果父类中也没有则报错。
2.成员方法同名时,优先在子类中找,找到则访问,否则在父类中找,找到则访问,否则编译报错。
3.成员方法同名时,如果父类和子类同名方法的参数列表不同(重载),根据调用方法适传递的参数选择合适的方法访问,如果没有则报错;
总结:
当子类中存在与父类中相同的成员时,不能在子类中直接访问父类相同的名称的成员。此时java提供了super关键字。
1.3.3super关键字的使用:
该关键字主要作用:在子类方法中访问父类的成员。
例6:super的使用
class Base{
int a=10;
int b=20;
public void methodA(){
System.out.println("Base中的methodA()");
}
public void methodB(){
System.out.println("Base中的methodB()");
}
}
class Derived extends Base{
int a=1;
char b;
public void methodA(int a){//与父类中的methodA()构成重载
System.out.println("Derived中的methodB()");
}
public void methodB(){//与父类的methodB()构成重写
System.out.println("Derived中的methodB()");
}
public void methodC(){
System.out.println("Derived中的methodC()");
//对于同名的成员变量,直接访问时,访问的都是子类的
a=100;//等价于:this.a=100;
b=101;//等价于:this.b=101;
//注意:this是当前对象的引用
System.out.println(a);
System.out.println(b);
System.out.println("===================");
//访问父类的成员变量(特别是同名变量,为了区分),需要借助super关键字
super.a=200;
super.b=201;
System.out.println(super.a);
System.out.println(super.b);
//父类和子类中构成重载的方法,直接访问可以通过参数列表不同来区分是访问父类还是子类的方法
methodA(20);//传递int参数,访问的是子类中的methodA(int)
methodA();//没有传参,访问的父类继承下来的methodA()
//如果在子类中访问重写的父类方法(类型,参数列表,返回值都相同),需要借助super关键字
methodB();//直接访问,永远都只能访问到子类中的methodB()
super.methodB();//访问的父类的methodB()
}
}
public class Test6 {
public static void main(String[] args) {
Derived derived=new Derived();
derived.methodC();
}
}
注意事项:
1.super和this都只能在非静态方法中使用,不能在静态方法中使用
2.在子类方法中,super可以间接访问父类的成员变量和方法
1.4子类构造方法:
父子父子,先有父再有子,即:子类对象构造时,需要先调用父类构造方法,然后执行子类构造方法。
例7:子类构造方法的实现
class Father{
public Father(){
System.out.println("Father()构造方法");
}
}
class Son extends Father{
public Son(){//子类构造方法
//super();//注意子类构造方法中默认会调用父类的无参构造方法:super();
//用户没有写的时候,编译器会自动添加,而且super()必须是子类构造方法中第一条语句。
//并且只能出现一次super()
//如果要调用父类的有参构造方法,就需要自己写super(参数);且在第一条语句。
System.out.println("Derived()构造方法");
}
}
public class Test7 {
public static void main(String[] args) {
Son son=new Son();
}
}
总结:
在子类构造方法中,并没有写任何关于父类构造的代码,但是在构造子类对象时,先执行父类的构造方法,然后执行子类的构造方法。因为:子类对象中成员是由两部分组成的,一个是父类继承下来的,另一个是子类新增的部分。故在构造子类对象时,先要调用父类的构造方法,把从父类继承下来的成员构造完整,然后再调用子类自己的构造方法,将子类新增的成员初始化完整。
注意:
1.若是父类显示定义无参或者默认的构造方法,在子类构造方法第一条语句默认有隐藏的super()调用,即调用父类构造方法。
2.如果父类构造方法是带有参数的,此时编译器将不再给子类生成默认的构造方法,此时需要用户为子类显示定义构造方法,并且在子类构造方法中选择合适的父类构造方法调用,否则编译失败。
3.在子类构造方法中,super(...)调用必须是子类构造方法中的第一条语句。
4.super(...)只能在子类构造方法中出现一次,并且不能和this(...)同时出现。
1.5再谈继承后的初始化:
关于继承时,实例代码块,静态代码块,构造代码块运行的顺序。
我们知道,没有继承时:
1.静态代码块先执行,有多个时,按顺序执行,并且只执行一次,在类加载阶段执行。
2.当有对象创建时,才会执行实例代码块,实例代码块执行完成后,最后构造方法执行。
而继承关系上的执行顺序:
例8:继承上代码块的执行顺序
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 Test8 {
public static void main(String[] args) {
Student student1=new Student("张三",20);
System.out.println("========================");
Student student2=new Student("李四",21);
}
}
通过执行结果分析总结:
1.父类静态代码块优先于子类静态代码,且是最早执行的
2.父类实例代码块和父类构造方法紧接着执行
3.子类的实例代码块和子类构造方法紧接着再执行
4.第二次实例化对象时,子类和父类静态代码块都将不会再执行
1.6java中的几种继承方式:
注意:java中不支持多继承
1.时刻牢记,我们写的类是现实事物的抽象。而我们真正在公司中所遇到的项目往往业务比较复杂, 可能会涉及到 一系列复杂的概念,都需要我们使用代码来表示, 所以我们真实项目中所写的类也会有很多。类之间的关系也会更加复杂。
2.但是即使如此, 我们并不希望类之间的继承层次太复杂。 一般我们不希望出现超过三层的继承关系。如果继承层次太多,就需要考虑对代码进行重构了。
3.如果想从语法上进行限制继承,就可以使用 final 关键字。
final关键字修饰变量,成员方法,类:
a.final修饰变量或字段,表示常量(即不能修改)
b.final修饰成员方法,表示该方法不能被重写
c.final修饰类,表示此类不能被继承
二*多态:
2.1多态的概念:
通俗来说,就是多种形态,具体就是去完成某个行为或者实现某个功能,当不同的对象去完成或者实现时产生不同的状态。
例:
1.对于动物来说:吃食物这个行为,对于猫来说,就是吃猫粮,对于狗来说就是吃狗粮。
这里:父类:动物;父类方法:吃食物的行为;子类:猫和狗;子类方法:对于猫来说就是吃猫粮的行为,对于狗来说就是吃狗粮的行为
2.对于打印机来说:打印这项功能,对于彩色打印机来说,就是实现彩色打印的功能,对于黑白打印机来说,就是实现黑白打印的功能。
这里:父类:打印机;父类方法:打印的功能;子类:黑白打印机和彩色打印机;子类方法:对于黑白打印机来说就是实现黑白打印的功能,对于彩色打印机来说就是实现彩色打印的功能。
2.2java多态实现条件:条件缺一不可
1.必须要在继承的体系下
2.子类必须要对父类中的方法进行重写
3.通过父类的引用调用重写方法
例9:多态的实现
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 static void eat(Animal animal){//通过父类的引用调用重写的方法,有个向上转型
animal.eat();//通过传参来判断animal引用哪个具体的对象,然后调用谁的重写方法
}
public static void main(String[] args) {
Dog dog=new Dog("小黄",2);
eat(dog);
}
}
class Dog extends Animal{
public Dog(String name, int age) {//子类继承父类的构造方法
super(name, age);
}
@Override //父类方法在子类重写
public void eat() {
System.out.println(name+"啃骨头");
}
}
分析: 当类的调用者在编写eat()这个方法的时候,参数类型Animal(父类),此时在该方法内部并不知道,也不关注当前animal引用指向的是哪个类型(哪个子类)的实例,此时animal这个引用调用eat()方法可能会有多种不同的表现(和animal引用的实例相关),这种行为就称为多态
2.3重写:
也称为覆盖,重写是子类对父类,非静态static,非private,非final修饰,非构造方法等的实现过程进行重新编写,返回值和形参列表,方法名都不能改变。重写的好处在于子类可以根据需要,定义特定自己的行为或者特定的功能。也就是说子类能够根据需要实现父类的方法。
方法重写的规则:
1.子类在重写父类的方法时,一般必须与父类方法原型一致:修饰符,返回类型,方法,形参列表要完全一致。
2.被重写的方法返回值类型可以不同,但必须是具有父子关系的。
3.访问权限不能比父类中被重写的方法的访问权限更低。
4.父类被static,private,final修饰的方法不能被重写,构造方法也不能被重写。
5.重写的方法,可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验。例如不小心将方法名字拼写错了 (比如写成 aet)。那么此时编译器就会发现父类中没有 aet 方法,就会编译报错,提示无法 构成重写。
2.4重写和重载的区别:
方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。
2.5向上转型和向下转型:
2.5.1向上转型:
实际上就是创建一个子类对象,将其当成父类对象来使用。
语法格式:父类类型 对象名 = new 子类类型;
使用场景:
1.直接赋值
2.方法传参
2.方法返回
例10:向上转型的场景的实现
public class TestAnimal {
//2.方法传参:形参作为父类引用,可以接受任意子类的对象
public static void eat(Animal animal){
animal.eat();
}
}
//===================================================
public class TestAnimal {
//3.坐返回值:返回任意子类的对象
public static Animal buyAnimal(String var){
if("狗" == var){
return new Dog("狗狗",1);
}else if("猫" == 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);
}
向上转型的优点:让代码实现更简单灵活。
向上转型的缺陷:不能调用到子类特有的方法。
2.5.2向下转型:
将一个子类对象经过向上转型之后当成父类方法使用,再无法调用子类的方法,但有时候可能需要调用子类特有的方法,此时:将父类引用再还原为子类对象即可,即向下转换(强制转换)。
例11:向下转型的实现:
public class TestAnimal {
public static void main(String[] args) {
Cat cat = new Cat("猫咪",2);
Dog dog = new Dog("狗子", 1);
// 向上转型
Animal animal = cat;
animal.sleep();
animal = dog;
animal.sleep();
if(animal instanceof Cat){//判断此时animail对象是否是Cat的子类
cat = (Cat)animal;//向下转型
cat.mew();
}
if(animal instanceof Dog){//判断此时animail对象是否是Dog的子类
dog = (Dog)animal;
dog.bark();
}
}
}
注意:向下转型用的比较少,而且不安全,万一转换失败,运行时就会抛异常。Java中为了提高向下转型的安全性,引入 了 instanceof ,如果该表达式为true,则可以安全转换。
2.6再谈构造方法中避免调用重写的方法:
例12:构造方法中实现重写
class B {
public B() {
// do nothing
func();
}
public void func() {
System.out.println("B.func()");
}
}
class D extends B {
private int num = 1;
@Override
public void func() {
System.out.println("D.func() " + num);
}
}
public class Test {
public static void main(String[] args) {
D d = new D();
}
}
分析:
1.构造 D 对象的同时,会调用 B 的构造方法。
2.B 的构造方法中调用了 func 方法,此时会触发动态绑定,会调用到 D 中的 func。
3.此时 D 对象自身还没有构造,此时 num 处在未初始化的状态,值为 0。
结论:
尽量不要在构造器中调用方法(如果这个方法被子类重写,就会触发动态绑定,但是此时子类对象还没构造完成),可能会出现一些隐藏的但是又极难发现的问题。