面向对象的深层了解

**

本周面向对象知识小结

**
**

面向对象特征二-----------继承

**
继承的概念: 定义一个独立的类,将其他类的共性内容抽取出来,放在独立类中,让这个独立的类与其他类产生一种关系,这种关系叫做继承关系.
格式: 子类名 extends 父类名{}
extends 表示继承

继承的优点 :
1.提高了代码的复用性(结构比较清晰).
2.提供了代码的维护性
3.类和类之间产生一种继承关系,为多态提供了前提条件

继承的特点

支持单继承,不支持多继承,但是可以多层继承.

继承中的注意事项

1.子类继承父类,可以继承父类的所有非私有的成员
2,本身私有的成员变量/成员方法只能在本类中访问,但可以提供公共访问方法.
3.子类继承父类,不能继承父类的构造方法,但是可以通过关键字super来访问,super()访问父类的无参构造,super(xx),访问父类的有参构造.
4.要适当是的运用继承

面试题
什么时候才能运用继承?
当A类是B类的一种,或者B类是A类的一种,体现"is a"的关系时可以使用继承关系 .

成员变量的访问方式:
子类继承父类,如果子类的成员变量名称和父类的成员变量名称不一致的情况.(分别访问)
子类继承父类,成员变量的名称和父类的成员名称一致的情况执行就近原则访问;
就近原则访问执行流程:
1.先在子类的局部位置找,若有则使用
2,若没有,在子类的成员位置中找,若有则使用
3.若没有,在父类的成员位置中找,若有则使用
4.若没有,则编译报错,说明正在访问一个不存在的成员变量

继承中构造方法的关系
1.在继承关系中,子类是不能继承父类的构造方法,但是可以通过super关键字访问父类的构造方法
2.继承关系中,子类的所有构造方法都默认访问父类的无参构造方法.

面试题
为什么创建子类对象时,先要执行父类对象的无参构造方法?

因为可能要用到父类的数据,所以先让父类的数据初始化,父类初始化完毕,然后执行子类的构造方法.(子类的数据初始化)

初始化模块
初始化模块的优先级: 静态的初始化模块>构造代码块>局部代码块

面试题
1.在继承关系中,子类继承父类,如果父类中没有提供无参构造方法,会出现什么现象?如何解决?

现象:子类的所有构造方法默认父类的无参构造方法,父类如果没有提供,则会报错

解决:1.手动给出父类的无参构造方法

2.如果手动不提供父类的无参构造方法

3.,可以间接的通过super(xx)来访问父类的有参构造初始化

4.通过this(),访问本类(子类)的无参构造方法 ,然后通过子类的无参构造中的super(xx),间接访问父类的有参构造

**2请说明为什么局部变量不能使用static关键字修饰而可以用final修饰呢?
因为局部变量本身是一个访问限定,跟方法有关,static不能修饰.局部变量,随方法调用而存在,随方法调用完毕而消失,static 修饰的变量有一个特点:可以共用,方法调用需要释放局部变量,产生冲突.但是可以通过final修饰,被final修饰的变量将变为一个常量.

方法重写(override)

概念:在继承关系中,子类出现了和父类一样的方法名,子类会将父类的方法覆盖掉,这种现象成为方法重写.

this和super的区别:
this:代表当前类对象的地址引用
super:代表父类对象的地址引用

final关键字 : 最终的,无法更改的(状态修饰符)
特点:
修饰成员方法:被final修饰的成员方法,该方法不能被重写
修饰类: 该类则不能被继承
修饰成员变量:此时变量就是常量
如果变量为基本类型,变量值不能再改变
如果变量为引用类型,该引用类型的对象不能重新开辟堆内存空间(堆内存地址值不变)

面向对象特征之三----------多态

多态的概念:
一个事物在不同时刻体现出来的不同状态

多态的前提条件
1.必须存在继承关系,无继承,不多态
2.必须存在方法重写
3.父类引用指向子类对象

多态的访问特点
成员变量: 编译看左,运行看左
成员方法:编译看左,运行看右
静态的成员方法:编译看左,运行看左(静态的算不上方法重写,和类有关)
构造方法:分层初始化(父类先进行初始化,然后子类初始化)

面试题
什么是方法重写?Overload和Override的区别?

方法重写;在继承关系中,子类和父类出现了一模一样的方法,子类会将父类的功能覆盖掉,这种现象成为方法重写

区别:方法重载:方法名相同,参数类别不同,与返回值无关.
参数不同: 参数类型是否相同
参数个数是否相同

多态的好处
1.提高了代码的复用性
2.提高了代码的扩展性

多态的弊端
不能访问子类的特有功能

面试题
如何访问子类的特有功能?
1.创建子类的具体对象访问子类的特有功能.
2.将父类的引用强转为子类的引用(前提必须存在向上转型).
父类引用指向子类对象(向上转型写法)
父类名 对象名 = new 子类名() ;
向下转型格式:
子类名 对象名 = (子类名)父类引用 ;

抽象类(abstract)

概念:在一个类中,如果该类存在一个功能,仅仅方法声明,没有方法体(抽象方法),需要将该类定义为抽象类.

抽象类的特点:

1.如果一个类中有抽象方法,该类一定是抽象类.如果一个类为抽象类,该类不一定有抽象方法.
2.抽象类不能实例化(不能创建抽象类对象)
3.抽象类必须强制子类完成的事情(将抽象类中的所有抽象方法重写)

面试题
如何解决抽象类不能实例化?
抽象类需要通过一个子类来进行实例化,父类引用指向子类对象,如果一个抽象类的子类不能实现实例化,那一定存在具体的子类.

抽象方法的格式:
权限修饰符 abstract 返回值类型 方法名(形式参数 ) ;

抽象类的成员特点
成员变量:可以定义变量,也可以定义常量
成员方法:可以定义抽象方法,也可以定义非抽象方法
构造方法:存在构造方法(无参构造/有参构造)

abstract关键字不能和那些关键字共存?
和final关键字冲突, final修饰成员方法不能被重写
和private关键字冲突. 私有的不能被继承
和static关键字冲突 static修饰和类有关,随类加载而加载

什么是方法重写?Overload和Override的区别?

方法重写;在继承关系中,子类和父类出现了一模一样的方法,子类会将父类的功能覆盖掉,这种现象成为方法重写

区别:方法重载:方法名相同,参数类别不同,与返回值无关.
参数不同: 参数类型是否相同
参数个数是否相同

接口(interface)
概念:体现事物的一种扩展性功能(本身不具备,经过学习才具备的功能)

注意事项:
1.接口中只能定义抽象方法
2.接口不能实例化,但是可以通过接口的子实现类来进行实例化
接口的子实现类

• 子实现类不是具体类(抽象类)---->抽象类不能实例化—存在具体的子类
• 子实现类研究的都是具体类! 因为具体的子实现类可以实例化(创建对象!)

接口的成员特点
成员方法:只能是抽象方法,存在默认的修饰符(public static)
成员变量:只能是常量 存在默认修饰符(public static final)
构造方法:接口中不存在构造方法

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

类与接口之间的关系:
实现关系:implements 一个类继承另一个类的同时,可以实现多个接口!
格式:类名 implements 接口名1,接口名2{
重写每一个接口中的抽象方法
}

接口与接口 :
是继承关系,extends (提高代码的复用性! 父接口中有的功能,子接口也具备该功能),既可以单继承,也可以多继承!

抽象类和接口的区别?

1.成员的区别: 成员变量:抽象类可以定义常量,也可以定义变量,接口只能是常量,存在默认修饰符.(public static final)

成员方法: 抽象类可以定义抽象方法,也可以定义非抽象方法. 接口只能定义抽象方法,存在默认修饰符(public abstract)

构造方法:抽象类存在构造方法,对数据进行初始化,接口无构造方法.

2 . 关系区别:

类与类:不论是抽象类还是具体类,都是继承关系.支持单继承,不支持多继承,但可以多层继承

类与接口:存在实现关系,一个类继承另一个类的同时可以实现多个接口

接口与接口:存在继承关系,支持单继承,也支持多继承

3.设计理念的区别: 抽象类在抽象多态中使用,存在继承关系,父类引用指向子类对象.

接口:体现的一个事物的扩展功能,本身不具备的功能,子实现类实现.接口存在实现关系,

方法形式参数和返回值问题

方法形式参数:
1.为基本数据类型,形参改变对实参无影响
2.为引用类型,有直接影响
具体类:调用该方法,实参传递该具体类对象
抽象类:调用该方法,实参传递该抽象类的子类对象
接口:调用该方法,实参传递该接口的子实现类对象

返回值问题:
引用类型:
具体类:,返回该具体类对象
抽象类:返回该抽象类的子类对象
接口:返回该接口的子实现类对象

内部类

内部类定义:在一个类中定义另一个类
内部类可以访问外部类的所有成员,包括私有
外部类访问需要创建对象

内部类的划分:
成员内部类定义:在外部类的成员位置的类
局部内部类定义:在外部类的成员方法中定义的类

访问静态成员内部类的成员方法:
外部类名.内部类名 对象名 = 外部类对象() . 内部类对象()

静态的成员内部类中的成员访问方式:
外部类名 . 内部类名 对象名 = new 外部类名 . 内部类名() ;

局部内部类分为局部变量为什么加final?
原因:局部变量生命周期随方法调用而存在,随方法调用完毕而消失,而当前局部变量被局部内部类在访问,在堆内存不会被立即回收,它还在使用这个局部变量,需要将这个局部变量变为常量,以便于局部内部访问.

匿名内部类
定义:是内部类的一种简化方法
格式:
new 类名/接口名(){
重写方法 ;
}
本质:继承或者实现该类的子类对象

选择排序:
思想:使用0索引的元素依次和后面索引的元素比较,小的往前放,第一次比较完毕,最小值出现在最小索引处!

private static void switchSort(int[] arr) {
for(int x = 0 ; x < arr.length-1; x ++) { // 循环次数比数组长度少一次
for(int y = x +1 ; y < arr.length ; y ++) {
//判断:如果后面元素比较前面的元素小,将小的往前放
if(arr[y] < arr[x] ) {
int temp = arr[x] ;
arr[x] = arr[y] ;
arr[y] = temp ;
}
}
}
}

总结

本周学习了面向对象的其他两个特征,其中有更多的知识点,目前我对匿名内部类,内部类,以及形参和返回值问题比较模糊,我会尽快将此处知识点消化.
通过这周的学习,让我认识到了一定要多多的敲代码,不能只看不练,是无法快速提高.熟练地联系,会让你更加理解知识,并且训练你的思维能力,有利于后面的学习和工作.