文中要点:继承.多态.抽象类.接口.代码块.
继承:
将多个类抽取位一个独立的类,让独立的类和多个类产生继承关系
继承父类中所有的东西,除过构造方法
继承的初始化:分层初始化
继承的关键字:extends
格式:
class 子类名 extends 父类名{
...
}
继承的好处:
1)提供了代码复用性,解决了代码的臃肿
2)它是多态的前提(多态的前提是必须有继承关系)
继承的特点:
子类继承父类,是继承了父类所有的东西(成员变量,成员方法,包括私有),但是子类不能使用私有的东西,只能通过父类的公共访问间接的让子类访问它.
继承的另外一个特点:
在Java中,继承只支持单继承,不支持多继承(子类名 extends 父类名1,父类名2,...)
例:
class Zi extendsFather,Monther{} 不支持的
但是,Java是可以支持多层继承...
例:
class Zi1 extends Father {}
class Zi2 extends Zi1 {}
class Zi3 extends Zi2 {}
继承中的注意事项:
1)构造方法不能被继承,但是通过super关键字去访问
2)私有的可以间接的去访问
3)什么时候使用extends?
假设:有一个A类
class A{
public void show1 () {}
public void show2 () {}
}
有一个B类
class B{
public void show1 (){}
public void method () {}
}
按照正常的情况:发现A类和B类中有共同的show1()方法,根据继承的概念,---->让B类继承A类
class B extends A{
public void method(){}
}
没有问题,但是继承了A类,show1(),show2()也继承过来了,可能show2()并不是我想要的功能;对于这种情况不要使用继承
继承体现的是一种"is a"的关系:
如果A是B的一种或者B是A的一种,这个可以使用继承!
水果
香蕉
苹果
橘子
人类
学生
老师
军人...
不要随意的使用继承,只要有"is a"的关系就使用它..
Java开发设计原则:
低耦合,高内聚
耦合:类和类之间的关系 ,尽量降低耦合性
内聚:指的是做一件事情能力(尽量使用一个类完成的事情不要多个类去完成..)
继承中成员变量的名称问题
当前子类继承父类的时候,子类和父类中的成员变量名称不一致的情况,非常简单,分别输出就可以了;
当子类和父类中的成员变量名称一致的情况:
1)先到子类的局部位置找,如果找到了,就输出
2)没有找到,到子类的成员位置找,有就输出,
3)在类的成员位置还没有找到,直接父类的成员位置找,有就输出
4)如果还没有,就保存了,不存在这个变量
问题:
要访问这个子类的局部位置的变量,直接可以访问.
需求:要访问Son类的成员位置的这个变量nun,如何访问
需求:要访问Father类的成员位置的变量nun.如何访问?
Java提供了关键字:super:代表的父类的空间标识(父类的引用或父类的对象)
this和super关键字的用法:
成员变量:
this:
this.成员变量; (访问当前类)
super:
super.成员变量;(访问父类)
构造方法:
this(); //无参构造
this("") ;//访问当前类的有参构造
super()://访问的父类的无参构造
super("")://访问的是父类的有参构造..
成员方法:
this.xx()
super.xx()
关于继承的成员的问题
构造方法:
子类继承父类,都会默认的访问父类的无参构造方法,为什么呢?
假设数据还没有被初始化完毕,所以应该先让父类进行初始化,然后在让子类初始化--->分层初始化
问题:
如果父类的无参构造没有提供?怎么办?
肯定报错;
如何解决:
1)可以将父类的无参构造提供出来
2)可以super关键字去访问父类的带参构造...
3)还可以在子类中通过this(),访问本类中的有参构造,间接的去访问父类带参构造
子类的构造方法必须有一个(有参构造/无参构造),让父类进行初始化!
继承中成员方法的问题
子类继承父类,访问成员方法名不一致的情况,分别调用!
当子类中的成员方名和父类中的成员方法名一致的情况:
1)现在子类的成员位置找,如果有就调用
2)如果没有找到,在父类的成员位置找,有就调用
----------------
关于继承的用法:
父类中被private修饰的,是可以继承,但是只能间接的去访问私有的..
父类被private修饰 成员属性,子类不不能直接访问的
子类不能继承父类的构造方法,但是可以通过super来调用;
子类继承父类,父类先进行初始化,然后子类进行初始化,这就是继承中分层初始化
类名 对象名 = new 类名() ; 这句话,创建了对象,通过构造方法进行初始化(默认初始化,显示初始化)
------------
方法重写:
由于子类继承父类的时候,提供一摸一样的方法声明,然后会将父类该方法覆盖掉(重写,复写)
有时候(具体的需求),不需要子类重写父类的功能,针对这种情况,Java提供了一个关键字:final 最终的,终态的意思
final不仅可以修饰基本数据类型
还可以引用类型
如果final修饰的是一个基本数据类型:基本数据类型的值不能再改变了...
如果final习俗的是一个引用类型数据:引用类型的地址值不能再改变了,但是堆内存中的成员变量的值可以变得
final的初始化时机:
1)被final只能被赋值一次(final int a = 10)
final int a ;
//在使用之前进行初始化,赋值(在构造方法之前赋值) (非静态的...)
面试题:
1.方法重写和方法重载的区别?
Overload:方法重载
方法名一样,参数不同,和返回值没有关系
参数不同:
1)参数个数不同
2)参数类型不同
Override:方法重写 (子类定义一个和父类一摸一样的方法声明)
继承中使用到的
2.final,finally,finalize的区别?
final修饰符（关键字）。被final修饰的类，就意味着不能再派生出新的子类，不能作为父类而被子类继承。因此一个类不能既被abstract声明，又被final声明。将变量或方法声明为final，可以保证他们在使用的过程中不被修改。被声明为final的变量必须在声明时给出变量的初始值，而在以后的引用中只能读取。被final声明的方法也同样只能使用，不能重载。
finally是在异常处理时提供finally块来执行任何清除操作。不管有没有异常被抛出、捕获，finally块都会被执行。try块中的内容是在无异常时执行到结束。catch块中的内容，是在try块内容发生catch所声明的异常时，跳转到catch块中执行。finally块则是无论异常是否发生，都会执行finally块的内容，所以在代码逻辑中有需要无论发生什么都必须执行的代码，就可以放在finally块中。
finalize是方法名。java技术允许使用finalize（）方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在object类中定义的，因此所有的类都继承了它。子类覆盖finalize（）方法以整理系统资源或者被执行其他清理工作。finalize（）方法是在垃圾收集器删除对象之前对这个对象调用的。
猫狗案例的继承版
猫:
属性: 姓名 ,年龄 , 毛色
行为: 玩毛线,猫吃鱼...
----->Cat 类
成员变量:name,age,color
成员方法:setXXX/getXXX()
playGame(),eat()...
构造方法:无参/有参
狗:
属性: 姓名 ,年龄 , 毛色
行为: 看门,狗吃骨头
----->Dog 类
成员变量:name,age,color
成员方法:setXXX/getXXX()
playGame(),eat()...
构造方法:无参/有参
---->将共性的内容抽取一个类中, Animal类
class Animal{
...共性内容
}
Cat类和Dog类分别继承自Animal类
------------
多态:
在同一个时刻,体现出来的不同状态;
水:
固态 气态 液态
猫狗案例的,创建猫的对象
Cat c = new Cat() ; 猫是猫
Animal a = new Cat() ;猫属于动物
多态的前提:
1)必须有继承关系
子类继承父类,存在一些特点
2)必须有方法重写
子类继承父类,方法重写的目的,举例:动物吃的方法,每一个具体动物吃的东西不一样,所有必须要方法覆盖
3)就是必须有父类的引用指向子类对象 (向上转型)
父类名 fu = new 子类名() ;
通过父类对象的创建是通过子类在堆内存新建了了一个对象,由于子类又继承了父类,
父类的引用(初始化)是通过子类新建对象进行的..
多态中的成员访问特点:
1)成员变量: 编译看左,运行看左...
2)成员方法(非静态): 编译看左,运行看右(存在方法重写)
3)构造方法:构造方法(无论子类,还是父类),都是对对象进行初始化
4)静态成员方法: 编译看左,运行看左(静态跟类有关系,算不上方法重写)
---------
多态的好处:
可以提供代码的复用性:继承保证
可以提高的代码的扩展性:由多态保证... (父类的引用指向子类对象)
--------
多态的弊端:
父类引用指向子类对象,
通过父类的引用调用子类特有功能,不能调用....
--------
多态的弊端:
不能访问子类特有功能
Father3 f = new Son3() ; 父类的引用指向子类对象 (向上转型)
可不可以将子类的引用指父类的引用呢? (向下转型)
将父类的引用强制转换子类的引用
----------
将父类的引用强制转换子类的引用 ,向下转型使用不当,会出现一个异常:属于运行时期异常:ClassCastException
--------
抽象类:
Java中,如果一个类中有一个方法声明(抽象方法)抽象功能,那么这个类定义为抽象类
关键字:abstract 抽象的意思
抽象类的特点:抽象类不能直接实例化!(不能创建对象) 接口也不能实例化
关于抽象类:
1)如果一个类中有抽象方法,那么这个类是一定是一个抽象类
2)抽象类必须有抽象方法吗? 抽象类中不一定都是抽象方法
抽象类的子类
1)如果子类是抽象类,没有意义,因为都不能实例化,对象如何创建
2)子类具体类,那么子类必须实现父类中的抽象功能.
抽象类的成员特点:
成员变量:可以是变量,也是一个常量
构造方法:可以有无参,可以有有参,
作用:给对象进行初始化的.
成员方法:可以有抽象方法,还可以有非抽象方法...
抽象类的一些注意事项:
A:一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
类中没有抽象方法也可以定义为一个抽象类,抽象类不能创建对象,
因此可以对于抽象类中的成员进行保护,不让用户去访问和赋值,但可以通过其他方式去实现访问;
B:abstract不能和哪些关键字共存
abstract和private 以后会说到!!!
abstract和final abstract抽象类是为了让子类去实现它,但是final本身就是终结的,最终得意思,和abstract本意相冲突;
abstract和static 静态和抽象不能同时使用
接口:
体现的是事务的扩展性功能(额外动作,后天经过学习等等)
接口格式(标识符:类,接口:见名知意)
interface 接口名{
//抽象功能
public abstract void jump() ;
}
接口的特点:不能实例化!!!!
接口和抽象类相似的特点在于同样需要实现类去实现其抽象功能;
接口的子实现类:实现类 (具体的实现类)
class 类名+impl implements 接口名{//接口的实现类名,一般默认为类名加Impl,为了阅读时能一眼看出这是一个接口的实现类
}
接口的子类如果是抽象类:没有意义,不能实例化
在现实过程中使用时:
接口多态(最多)
抽象类多态(比较多)
具体对象的创建(经常会使用)
接口成员的特点:
成员变量:是一个常量,不能更改,并且默认的修饰符
public static final:
构造方法:接口不存在构造方法
成员方法:都是抽象方法
默认的修饰符:public abstract
接口和接口之间的关系:继承关系
抽象类和接口的区别?
有三大区别:
1) 成员的区别
成员变量:
抽象类:既可以常量,也可以是变量
接口:只能是常量,默认的修饰符:public static final
构造方法:
抽象类:有构造方法,无参/有参 (给对象进行初始化的)
接口:没有构造方法
成员方法:
抽象类:可以有抽象方法,也可以有非抽象方法
接口:只能是抽象方法 :默认的修饰符:public abstract
2)类与类/类与接口关系的区别
类与类之间的关系:
继承关系,只支持单继承,不支持多继承,但是可以多层继承
类与接口的关系:
实现关系,一个类继承另一个类的同时,还可以实现多个接口...
接口与接口的关系:
是一种继承关系,既可以单继承,也可以多继承...
接口1 extends 接口2,接口3...
3)设计原则的 区别
1)抽象类: 是有继承关系---->体现的是一种"is a"的关系 (A是B的一种或者B是A的一种)
2)接口:类和接口:实现关系--->体现的是一种" like a"的关系(扩展功能) :跳高猫 像猫
类和类之间的关系:继承关系
类和接口之间的关系:实现关系
代码块
关于代码块的概述:
用{}括起来的代码,统称为代码;
根据其位置以及声明不同:分为以下:
局部代码块: 在main()里面,给变量限定它的生命周期
构造代码块:在一个类中的成员位置中,用{}括起来,
作用:可以将多个构造方法中的相同的代码放到构造代码块中,对对象进行初始化. 在每次执行构造方法之前,先执行构造代码块.
静态代码块:在一个类的成员位置,也是用{}包起来,但是他被static修饰
作用:一般情况 它的作用给类进行初始化
面试题:
构造代码块,构造方法,静态代码的优先级?
静态代码块>构造代码块>构造方法
静态代码:只能执行一次
构造代码块在每次执行构造方法之前都会被执行.