阶段学习小结

一：面向对象

1：this关键字的概念及目的

        this:代表当前类对象的地址值引用

        this的出现是为了防止局部变量隐藏了成员变量

2：匿名对象

匿名对象就是没有名字的对象

匿名对象的格式 new 类名(); 直接在堆内存开辟空间,使用完毕就要被回收,可以节省内存

匿名对象的好处：

        1)匿名对象可以作为参数传递 

        2)匿名对象可以节省内存空间,因为没有栈内存空间,不需要开辟,直接开辟堆内存空间

        3)匿名对象一般适用于一次即可,使用完毕,直接被jvm的GC(垃圾回收器)的回收

3：构造方法的特点以及注意事项

构造方法特点: 1)方法名和类名相同

                        2)没有具体返回值类型

                        3)连void都没有

构造方法的目的:就是为给类的成员初始化

构造方法的注意事项: 1)当在书写一个标准类的时候,没有给出任何构造方法.系统会默认提供无参                                          构造方法

                                   2)如果提供了一个类的有参构造方法,系统就不会构造方法,所以,建议永远给                                        出无参构造方法

                                  3)构造方法是可以重载的;

4：一个类成员的组成以及一个类的标准写法

一个类的组成   1)成员变量

                        2)构造方法

                        3)成员方法

一个类的标准类的写法:

                                1)成员变量私有化

                                2)无参永远给出的,有参构造根据题意要求

                                3)成员方法,根据题意要求

5：static关键字

static 本身含义共有,共享的意思----随着类的加载而加载(优先于对象的创建之前完成)

static关键字的特点：

1）被静态修饰的随着类的加载而加载，优先于对象存在

2）不能和this共存

3）本身含义就是共享，共用，可以多个对象共享共用

4）被静态修饰的成员变量或者成员方法（静态变量/静态方法）

6：代码块

代码块就是使用{}括起来的内容，主要分为：局部代码块和构造代码块

局部代码块：在方法中定义使用，{}作用是限定局部变量的生命周期

构造代码块：在类的成员位置定义，它有特点：在执行构造方法之前，如果类中有构造代码块，优先执行构造代码块，作用是可以给类的成员的数据进行初始化

只要执行构造方法，如果存在构造代码块，它必须优先执行，然后才是构造方法

静态代码块：类加载一次，静态代码块也就执行一次

优先级：静态代码块>构造代码块>构造方法，且每次执行构造方法之前，优先执行所有的构造代码块

7：局部变量和成员变量的区别

1)书写位置不同:
成员变量:类中,方法外!
局部变量:方法定义中,或者方法声明上
2)内置中的位置不同
成员变量:堆内存中,和对象有关系
局部变量:栈内存中,和方法有关系
3)生命周期不同:
成员变量:随着对象的创建而存在, 随着对象的创建完毕等待jvm的垃圾回 收器空闲 时
候回收而消失
局部变量:随着方法的调用而存在,随着方法调用结束而消失;
4)初始化值不同:
成员变量:是可以不初始化的,需要通过对象名来赋值,存在默认初始化;
局部变量:必须在使用之前初始化,否则报错;

8：什么是继承，继承的好处

将多个类的共性内容，抽取到一个独立的类中，让多个类和这个独立的类产生一种关系，这种关系叫做----继承关系

继承的好处：

        1）提高代码的复用性

        2）提高代码的维护性

        3）类和类的关系，是多态的前提条件

继承的特点：

        1）在java语言中，类和类的关系是一种继承关系，这种关系只支持“单继承”，不支持“多继承”

        2）类和类关系中，虽然不支持多继承，但是可以层层继承-----多层继承

注意点:

        1）子类继承父类，对于非私有的成员，直接可以继承过来，但是如果私有成员，可以通过公共方法进行访问

        2）被私有修饰的东西（成员变量/成员方法），只能在当前类访问

在继承关系中，构造方法的访问问题：

        子类继承父类，子类的所有构造方法都默认访问父类的无参构造方法；

例题：

如果一个父类存在有参构造方法，没有无参构造方法，子类的所有构造会出现什么问题，怎么解决

        子类的所有构造方法报错；

解决方法：

方案一：

        手动给出无参构造方法

方案二：

        在要求无需给出父类的无参构造方法的前提下时，应该使用关键字---super（代表父类空间标识）

方案三：保证子类的所有的构造方法某一个构造方法，让父类初始化完毕即可

重点-----子类继承父类，一定要先执行父类的构造方法，初始化完毕之后，才能执行子类的构造方法------分层初始化

9：子类继承父类，成员变量的访问问题

情况一：>>>>>子类和父类中的成员变量名称不一致，访问比较简单，分别访问即可

情况二：>>>>>子类和父类的成员变量名称一致

        1）先在子类的局部位置找有没有这个变量，有就使用

        2）如果没有,在子类成员位置中找,有没有这个变量,有就使用

        3）如果子类的成员位置也没有,然后会在父类的成员位置找,有没有这个变量,有就使用

        4）如果父类的成员位置都没有,报错(前提:这个父类没有它的父类了),说明整个子父类中都                    没有变量; *遵循"就近原则"

10：子类继承父类,关于成员方法的访问问题

情况一：>>>>>子类和父类的成员方法名称不一致,比较简单,分别调用即可

情况二：>>>>>子类和父类的成员方法一模一样:权限修饰符,返回值类型,参数列表都一样,子类将父类的方法覆盖了---->方法重写 :Override---->子类在父类的基础上,将父类的覆盖了,使用自己的功能

11：final关键字

在有的情况里面,父类的功能不能让子类覆盖 ,Java提供了一个关键字"final"

final:最终的,无法更改的,状态修饰符 ,被final修饰的成员方法,不能被重写,保证父类的方法安全性!

final关键字特点: 本身的含义:最终的,无法更改的

        1)final可以修饰类,该类不能被继承 

        2)final可以修饰变量,此时这个变量是一个"常量",常驻内存

12：多态

什么是多态?-----微观角度(内存中变化):具体对象在内存中的变化(对象在不同时刻的类型)

多态的前提条件 (重点)

        1)必须有继承关系(类与类),没有继承关系,不谈多态

        2)必须存在方法重写,子类部分功能要将父类的功能进行覆盖,重写,子类使用自己的功能体现

        3)必须存在父类引用指向子类对象

多态的弊端----------无法调用子类的特有功能

        如何解决呢 

                方案一：创建自己的子类对象

                                子类名 对象名 = new 子类名() ;

                                方案一不好的地方:本身Fu fu = new Zi() ;已经开辟堆内存空间了, Zi zi = new                                 Zi();又要在堆内存开辟空间,消耗内存空间比较大 ;

                方案二：可以向下转型，前提必须向上转型Fu fu = new Zi() ; Zi z = (Zi)fu ; 强转的语法                               方案二的好处:节省内存空间

多态的好处:

        1)提高代码的复用性,由继承保证的

        2)提高代码的扩展性,由多态保证 : 父类引用指向子类对象

注意问题---------针对多态的向下转型,前提必须有向上转型(父类引用指向子类对象)但是,写代码的                             时候,注意内存的中的变化,否则会出现一种 "异常" 

13：抽象类

什么抽象类? -----------------在一个类中,如果有抽象方法,这个类必须为抽象类

给某个事物的一些行为,不给出具体体现,在Java编程中,应该加入一个关键字 abstract,这些行为--->"抽象方法"，有抽象方法的类一定是抽象类,否则编译就会报错!

        抽象类中可以存在抽象方法,也可以存在非抽象方法

抽象的方法的格式: public abstract 返回值类型 方法名(空参/带参) ;

抽象类的特点:

1)不能实例化 (不能创建对象)

2)必须强制子类完成事情:必须将抽象方法重写!

抽象类的子类:

        如果子类是一个抽象类, 没有意义(抽象类new不了) (前提条件是这个子类没有它的子类)

       研究的抽象类的子类一定会有一个具体类,这个时候通过具体类才能创建对象

                抽象的父类名 对象名 = new 具体的子类名() ; 抽象类多态

抽象类的成员特点:

        成员变量:抽象类的成员变量既可以有变量,也可以是自定义常量被final

        成员方法:抽象类中既可以有抽象方法,也可也有非抽象方法

        构造方法: 既可以定义无参/有参构造方法.

存在抽象类多态,有继承关系,初始化的时候,构造方法----分层初始化---->先父类初始化,子类初始化

>>>>>abstract 和那些关键字冲突

private:因为被private私有的成员方法只能在本类访问,而abstract修饰的成员方法,必须强制子类重写,已经超出来的当前类的范围

final:被final修的成员方法,不能被重写;而抽象方法强制子类必须重写

static:abstract修饰的方法必须被子类重写,而static修饰的方法,算不上抽象,直接跟类相关的

abstract关键字 应用范围:

定义在类上---抽象类

定义在方法上----抽象方法---- public abstract 返回值类型 方法名(空参/带参...)  abstract 返回值类型                                               方法/名(空参带参...) 

子类继承父类,子类重写父类的抽象方法,必须保证访问权限足够大,要么加public要么跟父类的方法保持一致否则报错

14：接口

什么是接口? -------------------接口体现的是事物的一种额外功能 

Java编码中,体现这些事物本身不具备的功能,要经过一些特殊的实现才能具备功能-----称为 "接口"---关键字 interface

格式的写法

        interface 接口名{  

             class 子类名 implements 接口名{ } 

}

接口-----体现事物本身以外的额外功能，需要事物要对接口的功能进行实现，才具备

接口的最大特点: 不能实例化

如何实例化?--------------接口通过它的子实现类进行实例化

实际开发中:接口的子实现类名的命名---> 接口名的后面+Impl:表示是接口的实现类

接口的成员特点:  

1)成员变量:只能是常量,存在默认修饰符 :public static final

2)成员方法:只能是抽象方法,存在默认修饰符 public abstract

3)构造方法:没有构造方法的---通过子实现类的构造方法来实例化

接口本身意义:对外暴露这些功能,让子实现类实现

关于面向对象中牵扯关系问题:

Java中最基本的单元是类

类和类:继承关系 extends,Java语言中只支持单继承,不支持多继承,但是可以多层继承

类和接口: 实现关系 implements;一个类继承另一个类的同时,可以实现多个接口

接口和接口:继承关系:extends 不仅支持单继承,也可以多继承