标签：Java 构造方法 子类 成员 第三周 学习 访问 父类 方法

一、代码块编译执行的优先级

1.1、代码块：

        通俗的将，使用{}括起来的内容称为代码块。

1.2、分类：

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

        构造代码块：在类的成员位置(类中,方法外)，使用{}包裹起来  作用：给类中的一些成员进行数据初始化。特点:每次在执行构造方法之前,如果存在构造代码块,先执行构造代码块中的内容!

       静态代码块：在类的成员位置,直接使用 static{},特点:随着类的加载而加载,优先于对象存在!静态代码块就加载一次!

        代码执行的优先级：

        静态代码块>构造代码块>构造方法

二、静态static关键字，静态修饰符

2.1、static关键字特点

        1）随着类的加载而加载。

        2）优先于对象存在:  它不能this共存   (this:代表当期类对象的地址值引用)，对象还没有创建（new）的时候,当前被static修饰的成员就已经内存了。

        3）被静态修饰的，可以被多个对象共享，有共享共用的意思。

        4）被静态修饰的变量、方法

                        我们所说的成员变量和成员方法:都指的是非静态

                        静态的成员的访问方式:

                                        类名.变量               类名.方法名()

2.2、static关键字使用注意事项

        1）非静态的方法既可以访问静态变量,也可以访问非静态的变量。 既可以调用静态方法,也可以调用非静态方法。

        2）静态的方法：只能访问静态变量，只能调用静态方法。

       总而言之：静态只能访问静态。

三、面向对象三大特性之——继承

3.1、继承的概念：

        将多个类的共性内容抽取到一个独立的类中，然后让多个类和这个独立类产生继承关系。

        子类继承父类的的特征和行为，使得子类对象具有和父类的相同的行为和属性。

3.2、关键字extends

        继承的书写格式：

                                        class {

                                                  “成员变量；成员方法；构造方法”      

                                        }

                                        class 子类 extends 父类{

                                        }

3.3、继承的好处

        1）提高代码的维护性

        2）提高代码的复用性

        3）类和类之间的继承关系，是“多态”特性的前提条件。

3.4、继承的特点

        继承都是类与类之间的关系，其之间的特点是：

                类与类之间的继承关系，在Java中，只支持单继承，不支持多继承，既一个子类只能有一个父类。但支持多级继承，例：

                                             

举例：
    class A{      //有一个父类A
    }
    class B extends A{    //子类B继承父类A
    }
    class C extends B{    //子类B继承父类B
    }

 3.5、继承的使用注意事项

        1）子类继承父类：可以继承父类的非私有成员，私有的成员外界不能访问，只能在本类中访问，但是可以通过公共访问方法（set/get）访问。

        2）构造方法是不能被子类继承的，但是子类要访问父类的构造方法，可以通过关键字super来访问。

3.6、继承类中，各成员间关系

        首先，先搞清楚一个类中都有哪些成员？

        一个类的组成有：成员变量；成员方法；构造方法；

        在子类继承父类的时候，其成员间的关系如下：

成员变量/成员方法：遵循一个原则:就近原则!

               （1）子类继承父类，如果子类中的成员变量名称和父类的成员变量名称不一致,分别访问即可。

               （2）子类继承父类,如果子类的成员变量名称和父类的成员变量名称一致:如何访问呢?                     ①首先在子类的局部位置找,是否存在局部变量名称,如果有,就使用。

                ②如果没有,就在子类的成员位置找,是否存在这个变量,如果存在,就使用。

                ③如果在子类的成员位置中没有找到,直接在父类的成员位置中找,如果有,就是使用。

                ④如果父类的成员位置都没有,就没有这个变量,报错。

3.7、继承中构造方法的访问

（1）子类继承父类，子类的所有的构造方法都会默认的访问父类的无参方法。

        子类的所有构造方法的第一句话：默认隐藏了super() ；因为子类中会使用到父类的数据，所以在继承关系中得先让父类初始化，构造方法：分层初始化!(先父类无参构造方法，再执行子类的构造方法)。

        super：代表的父类对象的空间表示(父类对象的地址值引用!)

（2）如果父类中的无参构造方法没有,子类会怎么样?

        子类的所有的构造都会报错 ，因为子类所有构造方法默认父类的无参构造方法。

        解决方案：

                方式1：每次都手动给出父类的无参构造方法。

                方式2：在子类的构造方法中的第一句话，通过super(xxx)，间接的访问父类的有参构造方法 。

                方式3：只要子类的所有构造方法中一个能够让父类初始化即可!

                在子类的有参构造方法中:this()；访问本类的无参构造方法，然后在子类的无参构造方法中间接访问父类的有参构造方法super(xxx)。  

        通常开发中：子类的无参构造：默认访问父类的无参构造方法。子类的有参构造，直接访问父类的有参构造。

四、关键字this和super的区别

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

                super:代表的父类对象的地址值引用(代表父类的空间标识)

访问成员变量：

                this.变量名; 访问的本类中的成员变量

                super.变量名; 访问的是父类的成员变量

访问构造方法：

                this() ; 访问本类的无参构造方法

                super() ;访问的父类的无参构造方法

                this(xxx);访问的本类的有参构造方法

                super(xxx);访问的父类的有参构造方法

成员方法：

                this.方法名();访问的是本类的成员方法

                super.方法名() ;访问的是父类的成员方法

五、方法的重写

        方法的重写（override）：子类出现和父类一摸一样的方法声明。重写的目的是：子类有自己独有的功能方法，需要将父类的方法覆盖。

方法重写(override)和方法重载(overload)的区别：

        方法重载：

                        1）在同一个类中；

                        2）方法名相同，参数列表不同（参数顺序，参数类型，参数个数）；

        方法重写：

                        1）在继承关系的子类中；

                        2）重写的方法和父类的方法是一摸一样的方法声明（方法名相同，参数列表相同，方法返回值相同）；

                        3）访问修饰符，访问范围需要不小于父类的访问范围。

六、关键字final

        在有的不想让子类重写父类的功能; 父类的功能是独立的，Java提供了关键字:final。

        final是一种状态修饰符：最终的,无法更改的。

        final是一个状态修饰符，表示无法更改的，可以用于方法、类、变量当中，一旦用final关键字修饰后，将不能改变final所修饰的引用。        

final的特点：

                    1）可以修饰类，该类不能被继承
                    2）可以修饰成员方法，成员方法不能被重写
                    3）可以修饰变量，此时这个变量是一个常量（自定义常量）

七、面向对象三大特性之——多态

7.1、什么是多态

 多态是一个事物在不同时刻体现不同的形态。

        举例：

                        现实世界：水；有固态、液态、气态等。

                                          人都有吃饭的这个行为，但是有的人喜欢吃面食，有的人喜欢吃米饭...

 诸如此类，现实事物具有多态性，而对Java程序而言，是面向对象进行开发的，用java程序实现现实事物，其也具有多态性，具体体现在内存上的变化。

7.2、多态的前提条件

多态的前提条件：

        1）存在继承关系

        2）存在方法重写

        3）有父类引用指向子类对象——（也称为：向上转型）

例如下方的伪代码举例：父类引用指向子类对象

class Fu{}
class Zi extends Fu{
                //存在方法重写
}
格式: Fu fu = new Zi() ;

7.3、多态成员访问特点：

1）针对成员变量：编译看左，运行看左（左：父类）

2）针对成员方法：编译看左，运行看右（子类方法重写覆盖父类方法）

3）针对静态（static）方法：编译看左，运行看左。（静态方法不存在方法重写，随着类的加载而加载，用类名.方法名来访问）

4）构造方法：存在继承关系，父类先初始化，子类再初始化。

7.4、多态的好处

1）提高代码的复用性：由继承保证

2）提高了代码的扩展性：由多态保证 

7.5、多态的弊端

不能访问子类的特有功能。

(Fu f = new Zi()）子类特有的功能，既父类没有的方法，使用多态无法调用访问子类方法。那么解决方案如下：

        方式一：直接创建子类对象，使用子类对象直接调用。

                       Zi z = new Zi() ；

                        z.方法名（）；

                        这种方法对比方式二，相当于多开辟了z类的空间，相较而言更小号内存空间，所以更常使用方式二。。

        方式二：（向下转型）

                        多态是父类引用指向子类对象，如下：

                        Fu f = new Zi()；

                        可以使用强制类型转换，

                        Zi z = (Zi) f;将其直接转换为子类类型：目标类型 变量名 = （目标类型）初始化值。

在使用向下转型的时候，前提必须要有父类引用指向子类对象（Fu f = new Zi()）；同时遵循转换格式。

八、关键字——abstract抽象类

        在现实世界中，许多事物都是概括性的，例如，动物、植物、水果等等，是一个概而广泛的抽象事物，只有具体的才有响应属性和行为，例如：狗，猫，苹果，香蕉，松树等等，是现实世界具体的事物。

        在java中，将某些类的方法仅仅给出声明，没有方法体的称为抽象方法，这个称为抽象类。用关键字abstract修饰。

        抽象方法的格式：

                权限修饰符(一般情况都是public) abstract 返回值类型  方法名(形式参数列表) ;

         抽象类的格式:

                abstract  class 类名{}

8.1、抽象类的特点

        1)有抽象方法的类一定是抽象类

        2)抽象类中不一定只有抽象方法 ,还可以非抽象方法(有方法体)

        3)抽象类不能实例化

        4)抽象类的子类有两种情况:

                        ①如果抽象类的子类都是抽象类，那么毫无意义，除非再有具体的子类。

                        ②抽象类的子类具体类才能创建具体对象实例。

        抽象类的核心宗旨:就是强制子类必须完成的事情(要将父类中的所有的抽象方法必须重写,否则报错!)

8.2、抽象类成员特点

成员变量：既可以定义变量,也可以常量:被final修饰

成员方法：既可以定义为抽象方法,也可以定义为非抽象方法，如果定义为抽象方法:关键字

                  abstract(显示给出)

构造方法：存在无参构造/有参构造方法---->目的:分层初始化        

8.3、和abstract冲突的关键字

private冲突：

        私有的方法,只能在本类中访问,加入abstract目的需要被子类重写,需要调用子类的功能。

static冲突：

        静态方法随着类的加载而加载,而静态方法不存在重写。

final冲突：

        被final修饰的成员方法是不能被重写的，而加入abstract的方法需要被重写的!

可以共存的有public protected

九、接口

        现实世界中，某些具体事物具备其它同类不具备的功能。例如：某些狗可以计算或者钻火圈等等技能，是其它狗类不具备的。

        在Java中，将这些类的额外扩展功能称为接口

        定义格式：interface  接口名{} 

        子实现类：class 子类名 implements 接口名{}

        接口中的方法:不能有方法体,隐藏public abstract关键字,只能是抽象方法,不能有方法体

9.1、接口的特点

        不能实例化（不能创建对象）

        解决方案：

                通过接口的子实现类进行实例化，也是接口的多态。

9.1.1、接口的成员特点

        （1）接口中的成员方法:只能是抽象方法,默认的修饰符:public abstract(可以省略不写)

        （2）接口没有构造方法

        （3）接口的成员变量只能是常量：存在默认修饰符:public static final (可以省略不写)

9.2、接口和抽象类的区别

        1)成员的区别

                抽象类:

                        成员变量:既可以是变量,也可以是常量

                        成员方法:可以存在抽象方法(必须携带abstract关键字),也可以有非抽象方法

                        构造方法:存在无参/有参构造方法,---目的需要给数据进行初始化,分层初始化

                接口:

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

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

                        构造方法:没有

        2)关系的区别

                类与类之间: 继承关系,只支持单继承,不支持多继承,但是可以多层继承

                类与接口:   实现关系,一个类继承另一个类的同时可以实现多个接口,中间逗号隔开

                接口与接口: 继承关系,可以支持单继承,也可以支持多继承,多层继承  

        3)设计理念

                抽象类：强制子类必须完成的事情,由于存在继承关系,体现的是一种"is a"的关系。

                接口：体现某个事物额外的功能,谁实现该接口就具备该功能,体现的是一种"like a"的关系!

十、权限修饰符

                                        同包同类           同包不同类            不同包子类          不同包无关类

私有修饰符：private             √                          

默认修饰符                           √                        √                                

受保护的：prptected            √                        √                               √

公共的：public                     √                        √                               √                        √

修饰的权限从小到:private,默认,protected,public

十一、引用类型为形式参数

1）形式参数为类：

        具体类,调用该方法,实际参数需要传递当前具体类的对象

        抽象类,调用该方法实际参数需要传递的抽象类的子类对象 (抽象类多态)

2）形式参数为接口：        

        调用该方式,实际参数需要传递的是当前接口的子实现类对象(接口多态)

    另外，当引用类型为返回值类型时：其要求与上面的一致。

十二、内部类

内部类：在一个类中定义了一个新的类。  

例： 在类A 中定义了类B,将类B就称为类A的内部类,类A就是外部类!

成员内部类:

        在一个类的成员位置中定义了另一个类

        内部类可以访问外部类的成员,包括私有!

12.1、外部类访问内部类成员

1、格式：外部类名.内部类名  对象名 =  外部类对象.内部类对象;

2、当前成员内部类是静态时，里面的方法无论是静态的还是非静态的,都只能访问外部类的静态成员,包括私有。

3、访问静态内部类的成员

        直接访问方式：外部类名.内部类名 对象名 = new 外部类名.内部类名()       

        

             

标签：Java,构造方法,子类,成员,第三周,学习,访问,父类,方法
来源： https://blog.csdn.net/qq_34288595/article/details/119032953

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。