Java面向对象—多态性及内部类

继承使用原则:
1.实例化子类前首先实例化父类。
2.单继承局限
3.显示继承与隐式继承

super:修饰属性 表示调用父类属性
修饰方法 调用父类方法I.修饰构造方法super(方法参数);

方法覆写(override)与方法重载(overload)

final-终结器
final属性-常量
final方法-不能被覆写
final类-不能有子类

多态:同一个类实例的相同方法在不同情形下有不同的表现形式。
作用:使代码更加灵活方法
多态:方法覆写方法重载
对象多态:
向上转型(90%):天然发生,认爹

父类 父类引用= new       子类实例();
Person per=new Student();

应用场景:参数统一化

向下转型(1%):需要强转,发生向下转型之前一定首先发生向上转型,否则会抛出ClassCastException(运行时异常,类型转换异常,发生在两个毫无关系的类之间的强转时)。

子类 子类引用=(子类) 父类实例;
Student stu=(Student) per;

引用对象 instanceof 类:表示该引用能否指向该类,返回true表示可以指向,返回false表示不能指向。
因此,向下转型的标准格式如下:

if(!(per instanceof student)){
    per =new Student();
}
Student stu =(Student) per;

应用场景:发生在父类引用需要调用子类扩充的方法时,才发生向下转型变为子类引用调用其扩充方法。
无论是向上转型还是向下转型,本质在于发生了方法覆写

内部类:将内部类视为属性来看待(人和心脏的关系)
定义:所谓的内部类只是在类的内部进行了类结构的嵌套操作内部类最多嵌套两层
根据内部类定义的位置以及关键字一共分为以下四种内部类:
内部类的优点有
1.内部类与外部类可以访问彼此的私有属性(内部类直接访问,外部类通过内部类对象访问)
2.使用内部类可以实现多继承的概念

 class A{}
 class B{}
 class C{
       class D extends A{}
       class E extends B{}
}

3.内部类可以对外部类完全隐藏(保护性)私有内部类

class Outter{
      //Inner类只能在Outter中使用,并且对Outter外部完全隐藏
      private class Inner{}
}

内外部类的关系:I
.成员内部类的创建需要依赖外部类对象,先有外部类对象而后才可以产生成员内部类对象。
II.内部类是一个相对独立的个体,与外部类不是is-a的关系
III.内部类可以直接访问外部类的元素,外部类需要通过内部类对象间接访问内部类元素

静态方法能否访问普通属性?不能普通属性能否访问静态属性?可以

成员内部类(普通内部类)-类比普通属性/方法定义:直接定义在外部类之中,不加static修饰符
在外部类的外部创建成员内部类语法:

外部类.内部类 内部类名称=new 外部类().new 内部类();
Outter.Inner in=new Outter ().new Inner();

成员内部类的限制:成员内部类可以访问外部类的静态属性,成员内部类不能拥有静态域(静态方法与属性都不行)
静态内部类 -类比静态属性/方法定义:直接定义在外部类之中,加static修饰符
静态内部类只是包在外部类内部而已,除此之外与普通类没有任何区别,不再需要外部类对象。
在外部类外部创建静态内部类语法:

外部类.内部类 内部类名称=new 外部类.内部类();
Outter.Inner in=new Outter.Inner();

静态内部类限制:静态内部类能拥有普通域,但是不能访问外部类的普通域.

方法内部类-类比于方法中的一个局部变量定义在方法中,不加任何修饰符,与普通内部类基本一致,只是作用域不同。
1.方法中若存在内部类,方法形参使用隐式的final声明(JDK8之前使用显示final声明),因此方法内部类只能使用形参而无法修改方法形参的值。
2.方法内部类不能使用任何权限修饰符

public private protectedclass Outter{
    private int num=0;
    public void test(final int data){
        class Inner{
            public void fun(){
                 num++;
                 System.out.println(num);
                 System.out.println(data);
            }
        }
    }
}

匿名内部类:等同于方法内部类,就是没名字而已,但是匿名内部类必须继承一个抽象类或者实现一个接口。除此之外与方法内部类完全一致。

abstract class Person{
    public abstract void print();
    //在抽象类内部提供一个实现好的子类。
    public static Person getInstance(){
        //匿名内部类
        //等同于class 无名 extends Person
        return new Person (){
            public void print(){}
        };
    }
}

抽象类与接口方法重写:多态的关键所在为了强制要求子类必须覆写父类方法产生了抽象类与接口。
1.定义:
抽象类:是普通类的超集,只是比普通类多了一些抽象方法而已。
抽象方法:使用abstract关键字定义的只有方法声明没有方法体的方法。

public abstract void test();

抽象类中包含抽象方法,则抽象类也必须使用abstract来定义,表示抽象类。//半成品

class Person{
    private String name;
    private int age;
    public void setName(String name){
        this.name=name;
    }
    //只声明而未实现的方法
    public abstract void getPersonInfo();
}

public class Test{
    Run|Debug
    public static void main(String[] args){
       new Person();
       }
 }

本地方法(Java调用C同名方法):使用native定义的只有方法声明没有方法体的方法。

 pubilc native int hashCode();

2.抽象类的使用限制
a.所有抽象类必须有子类(final与abstract不能同时出现)
b.抽象类的子类必须覆写所有抽象方法(或者子类也使用abstract关键字定义)private与abstract不能同时出现,抽象方法必须被覆写而private方法无法被覆写。
c.抽象类无法直接产生实例化对象,但可以通过子类向上转型进行实例化。且子类依然遵循对象实例化流程,先调用抽象类构造方法而后再调用子类构造。
d.抽象类可以没有抽象方法,但是此时仍然不能直接实例化对象。

    原文作者:X__太瘦
    原文地址: https://blog.csdn.net/Adavinajh/article/details/88142084
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞