Java面向对象(类的封装,继承和多态)

 

面向对象:世间万物皆对象:
    特性:封装 继承 多态
Java回收机制回收的是堆中的垃圾

类:
    概念:
        对一类事物的描述,引用类型,数据在堆中存储
    静态性的特征描述:字段
    动态性的行为描述:方法
    
对象(实例):
    客观世界中真实存在的,某一类事物的某一个个体
    对象的属性分配在堆内存中,但是对象名分配在栈内存中

    
一个类中的成员:
    1)字段(属性,成员变量,全局变量):
        声明:
            [访问修饰符] 数据类型 变量名[=初始值];
        局部变量:
            在方法内部/方法中的参数或代码块中声明,必须有初始值,生命周期与方法调用有关
        字段:
            在方法外面,类的内部进行声明,可以没有初始值,生命周期与对象有关
        默认初始化:
            整数型:0
            浮点型:0.0
            字符型:\u0000
            布尔型:false
            引用类型:null
        显式初始化:
    2)方法:
        [访问修饰符] 返回值 方法名([参数列表]) {方法体}
        返回值:
            无:void
            有:需要些返回值类型,必须由return语句
                return:必须保证每个条件分支都有return
                    return语句必须是可执行代码的最后一句
        参数列表:
            实参=形参;
            参数传递:
                方式:
                    值传递,Java只有值传递
                        传值(传值类型的参数):
                            把实参的值赋值给形参,实参不随着形参的变化而变化
                        传引用(传引用类型的参数):
                            把实参的值(引用类型的地址)赋值给形参,实参有可能随着形参的变化而变化(重新new一个就不会变)
                        递归:自己调用自己
                            条件:
                                1)要有返回值
                                2)必须有临界条件
                                斐波那契数列,汉诺塔
                        
    3)构造器(构造方法):构造对象,没有构造器产生不了对象
        如果该类没有写构造器,系统默认提供一个公开的无参的构造器
        如果该类显式编写了构造器,系统将不再提供默认的构造器
        特征:
            1)与类同名
            2)没有返回值,也没有void
            3)不能在方法中使用return
        声明:
            [访问修饰符] 类名([参数列表]) {初始化成员变量}
    4)内部类:内部类就是定义在另一个类的内部的类
        好处:
            1)对外可以隐藏外部类的细节
            2)对于内部类来说,外部类的所有成员均有访问权限
            3)内部类可以模拟实现多继承(接口和内部类)
            4)接口和父类中某个方法同名,通过内部类解决
        分类:
            1)成员内部类:
                1-1)实例内部类:
                    1)定义在方法外部,没有static修饰的内部类称为实例内部类
                    2)在外部类中可以直接创建内部类对象
                    3)如果在其他类中创建内部类对象,必须先创建外部类的对象实例,然后在外部类实例的基础上创建内部类对象实例
                        外部类.内部类 变量名=外部类对象实例.new 内部类();
                    4)内部类可以直接访问外部类所有的成员,外部类如果想要访问内部类的成员,必须创建内部类的对象实例,通过实例访问
                    5)在内部类中不能定义静态成员,只能定义实例成员
                    6)如果内部类中的成员或者局部变量和外部类成员同名: 
                        外部类名.this.成员名  表示外部类的成员
                        this.成员名 表示内部类的成员
                1-2)静态内部类:
                    1)在方法外部用static修饰的内部类称为静态内部类
                    2)静态内部类可以直接访问外部类中的静态成员,如果需要访问实例成员,则需要通过实例访问
                    3)在其他类中创建内部类对象,可以直接new创建,不必通过外部类对象实例
                        外部类.内部类 变量名=new 外部类.内部类();
                    4)在静态内部类中,可以定义静态成员和非静态成员
                    5)在其他类中可以通过完整的类名访问内部类的静态成员   外部类.内部类.静态成员
            2)局部类:
                2-1)局部内部类:
                    1)在一个方法内部定义的内部类称为局部内部类
                    2)局部内部类只在方法内部可见,方法外部无法使用
                    3)局部内部类类似于局部变量,不能使用private/protected/public/static修饰
                    4)局部内部类中不能包含静态成员
                    5)局部内部类可以直接访问所有的外部类成员和方法内final类型的参数和变量
                2-2)匿名内部类:
                    
                    1)匿名类是一种没有名字的特殊内部类
                    2)可以定义在方法的内部,也可以定义在方法的外部
                    3)匿名类本身没有构造器,但是可以调用父类的构造方法
                    4)没有访问修饰符
                    5)父类或者父接口 变量名=new 父类或者父接口(){匿名类的成员}
                    6)A a = new A(){}
                        如果A是一个类或者抽象类,则相当于定义并创建了A类的子类的实例并赋值给A类型的变量(a是一个多态对象)
                        如果A是一个接口,则相当于定义并创建了一个实现A接口的类的实例并赋值给A类型的变量
                    7)lambda表达式:jdk1.8之后出现,只能是接口的
                        作用:
                            1)当做是一个匿名方法使用
                            2)允许我们将行为传递到函数里
                        语法:
                            （参数）->{//方法体}
    
垃圾回收机制:
    对象会被回收情况:
        1)对象的引用被置为null
        2)使用的匿名对象
        3)超出生命周期
        
封装: 
    步骤:
        1)将字段私有(private)
        2)公开getXxxxw()或者setXxxx()方法访问该字段
        this:这个,代词,谁调用就指谁
            区分成员变量和局部变量的,在成员变量前加this
    好处:
        1)隐藏类中的细节
        2)方便修改的实现
        3)只能通过规定的方法访问
        
继承:单继承  一般类与特殊类之间的关系  耦合度最高
    子类的成员:
        1)继承父类的可视化(非私有)的成员(字段/方法),构造器不能被继承
        2)子类所特有的成员(字段/方法/构造器)
        3)重载父类的成员(方法)  ---编译时多态(多态的一种)
            3-1)重载的条件:
                3-1-1):发生在统一个类或者父子类之间
                3-1-2):方法名称相同,参数列表不同(数据类型/参数个数/参数顺序),作为判断重载的条件
                3-1-3):返回值无所谓,可以相同也可以不同,不能作为判断重载的条件
                3-1-4):访问权限无所谓
            3-2)重载的本质:
                两个毫不相关的方法
            3-3)重载的调用:
                避免歧义重载,否则编译错误
            3-4)构造器重载:
                3-4-1):this的2种用法: 指向本类的引用
                    a)this.成员:调用本类的方法和字段,谁调用指的是谁
                    b)this([参数列表]):调用本类其他的构造方法,根据参数列表来进行匹配,这句话必须在构造方法的第一句
        4)覆盖[重写]父类的成员(方法): 运行时多态
            4-1)覆盖的条件:
                4-1-1):发生在父子类之间(继承关系中)
                4-1-2):方法名称相同,参数列表相同(参数的数据类型/参数的个数/参数的顺序)
                4-1-3):返回值类型必须相同
                4-1-4):子类覆盖方法的访问权限必须大于父类被覆盖方法的访问权限
                4-1-5):子类不能抛出比父类异常类更大的异常(运行时异常例外)
            4-2)覆盖的本质:
                替换
            4-3)super:指向父类的引用
                4-3-1)super.成员:调用父类的方法/字段
                4-3-2)super([参数列表]):super中的参数决定调用父类的哪一个构造器
                4-3-3)系统默认调用super();:调用父类中无参的构造器;如果父类没有无参的构造器,则需要在子类的构造器中显示调用super(参数列表)或者this(参数列表),否则报编译错误
                4-3-4)super();只能出现在子类的构造器中,且必须是第一行
        PS:this和super不能在同一个构造器中同时出现
        5)隐藏父类的成员(字段/静态方法):
            子类中定义了一个与父类中相同的字段(普通字段即可),那么父类中的字段会被隐藏,普通方法不会隐藏,只会覆盖,只有静态方法会被隐藏,隐藏不会发生动态绑定
    
    多态对象:向上造型
        父类的对象指向子类的实例,该对象叫多态对象
        父类 对象名(多态对象) = new 子类();
    
        动态绑定:
            父类 对象名(多态对象) = new 子类();
            父接口 对象名(多态对象) = new 实现类();
                编译时对象是父类的类型,运行时是子类的类型,所以是动态绑定,该对象不能直接调用子类所特有的成员
        多态对象:
            1)调用覆盖的方法调用的是子类的;
            2)调用隐藏的成员,调用的是父类的
        多态存在的三个必要条件:
            1)要有继承或实现
            2)要有重写
            3)父类引用指向子类对象
        多态的优点:
            1)简化代码
            2)改善代码的组织性和可读性
            3)易于扩展
        多态的应用:
            方法的参数或者返回值使用父类的类型,数组中的元素是子类的类型
            Animal[] array = new Animal[3];
            array[0] = new Cat();
            array[1] = new Dog();
        
    继承的好处:
        1)代码重用,减少了代码的冗余
        2)使编码更高效
        3)易维护
    继承的缺点:
        1)耦合度比较高
    继承的声明方式:
        [访问修饰符] class 子类 extends 父类 {成员}
        子类:派生类/孩儿类
        父类:原生类/超类/基类
    继承的规则:
        1)Java中只支持单继承,也就是说每个类只能有一个父类,不允许有多重继承
        2)一个父类可以有多个子类
        3)子类继承父类所有的属性和方法
            子类继承父类,拥有父类的所有属性和方法,但是对于父类私有的(private),子类没有使用权,只有拥有权
    继承子类实例化过程:
        1)子类实例化时先实例化其父类,然后实例化子类
        2)要先调用父类的构造器,父类构造器运行完毕,才调用子类的构造器
        
        

格式良好的Java文件:
    [包声明语句]; package 包名;
    [导包语句]*; import 包名;
    类声明语句; class      public类只能有一个
    
    
包(package): 全部小写(Internet的倒叙)      .  
    功能:
        1)有助于避免类名冲突问题
        2)包允许将类组合成较小的单元
        3)包允许在更广的范围内保护类/数据和方法
import:
    1)java.lang.*:默认包,默认自动导入;
    2)java.io.*:输入输出流;
    
    1)使用通配符*,是把当下包的所有的类都加载到内存,消耗内存
    2)导包时只能看到导入包下的类以及其子包,不能访问子包下的类
    
类之间的关系:
    1)泛化(is-a):继承.
    2)实现:
    3)组合(has-a):一个类作为另一个类的成员变量
        3-1)合成:个体和整体的关系,生命周期相同
        3-2)聚合:个体和整体的关系,生命周期不同
        3-3)关联:
    4)依赖(use-a):一个类作为另一个类的方法的参数或者返回值
    
造型(引用数据类型(父子类)的转换):
    1)向上造型:自动转换   小(子类)-->大(父类)
    2)向下造型:强制转换   大(父类)-->小(子类)
        如果能够下转型的对象必须经过上转型,即多态对象.
    
    变量 instanceof 类[接口]          判断变量所指向的实例是否是类[接口]的实例
    
访问权限:
    private < default(friendly) < protected    < public
    有两个访问权限与包有关:default    protected
        1)private:只能本类访问
        2)default:只能同一个包中访问
        3)protected:同一个包中的类或者不同包的子类中可以访问
        4)public:不论是不是同一个包的类都可以访问
        
关键字:
    1)static:静态的,类的,与对象无关   不能修饰局部变量
        1)字段(成员变量=实例变量):类变量/静态变量
            特点:
                所有的对象共享
        2)方法:类方法/静态方法,不需要实例化,可以直接访问
            2-1)静态方法可以直接访问静态成员,不能直接访问非静态的成员,如果需要访问,则需要创建实例对象间接访问
            2-2)非静态方法可以直接静态成员和非静态成员
            2-3)静态方法中不能有this和super关键字
        3)块:静态代码块/静态块
            语法:
                static{}
        特点:
            1)类一加载就执行,只执行一次,比构造器先执行,一个类中可以有多个,按照书写顺序执行
            2)非静态代码块(实例代码块)也比构造器先执行,创建一个对象就执行一次,可以有多个,按照书写顺序执行
        初始化:
            1)实例变量初始化:声明时/构造器
            2)静态变量初始化:声明时/静态代码块
        4)内部类:
    2)final:终态的
        1)变量:常量,不能第二次赋值,必须要有初始值,声明时或者构造器中赋值
        2)方法:不能被重写
        3)类:不能被继承 
    String类没有子类,因为是final修饰的
    3)abstract:抽象的
        抽象方法:只有方法的声明,没有方法的实现
        抽象类:
        1)抽象方法必须放在放在抽象类中,抽象类中不一定有抽象方法
        2)抽象类不能有实例
        3)抽象类有构造器,其构造器不能用来产生本类对象,在子类产生对象时,间接调用该构造器
        4)抽象类有父类,父类可以是抽象类,也可以是非抽象类
        5)抽象类中可以有抽象方法,也可以由非抽象的方法
        6)abstract不能与private/static/final一起使用
        7)抽象类的所有抽象方法需要在子类中重写,如果只重写一部分,则子类仍然是抽象类
        
     在下列情况下,一个类必须声明为抽象类：
        1)当一个类的一个或多个方法是抽象方法时
        2)当类是一个抽象类的子类,并且没有实现父类的所有抽象方法,即只实现部分
        3)当一个类实现一个接口,并且不能为全部抽象方法都提供实现时
    4)interface:标准/规范, 没有构造器也没有实例
        访问权限:
            只能是public,默认public
        成员:
            常量: public static final 
            抽象方法:
            默认方法:有方法体,jdk1.8以上
        作用:
            模拟实现了多继承,将毫无关系的类根据某个特征关联起来
        声明:
            [访问修饰符] interface 接口名 {}
        
        
类和类之间:单继承 extends
类和接口之间:多实现 implements
接口和接口之间:多继承 extends
    
单例模式:
    要点:
        1)某个类只能有一个实例
        2)它必须自行创建这个示例
        3)必须自行向整个系统提供这个实例

    步骤:
        1)构造器私有
        2)产生本类唯一一个静态实例
        3)公开一个静态的方法返回该实例
    
    
多例模式:负载平衡

接口和抽象类的相同点与异同点:
    相同点:
        1)都是抽象类型
        2)都可以有实现方法(以前接口不行,jdk1.8才支持)
        3)都可以不需要实现类或者继承者去实现所有方法(以前不行,现在接口中的默认方法不需要实现者去实现)
    异同点:
        1)抽象类不可以多重继承,接口可以(无论是多重类型继承还是多重行为继承)
        2)抽象类和接口所反映出的设计理念不同,抽象类表示的是"is-a"的关系,而接口表示的是"like-a"的关系 
        3)接口中定义的变量默认是public static final型, 且必须给其初始值,所以实现类中不能重新定义,也不能改变其值;抽象类中的变量默认是friendly型,其值可以在子类中重新定义,也可以重新赋值