1)概念:
将多个类的共性内容抽取出来,放在一个单独类中,让这一个类和多个类产生一种关系"继承".
2)特点:
1)在Java语言中;类与类之间的继承关系,只支持单继承. 2)虽然类与类之间只支持单继承,但是可以多层继承.
3)格式:
class 父类名{
}
class 子类名 extends 父类名{
}
4)好处:
1)提高代码的复用性. 2)调高代码的维护性格. 3)类与类产生这种关系"继承",是多态的前提条件.
5)加入继承后的成员变量的访问问题:
情况1:
子类继承父类,子类的成员变量名称和父类的成员变量名称不一致的情况:很简单,分别调用即可!
class Fu2{
//父类的成员变量
int num = 100 ;
}
//定义一个子类
class Zi2 extends Fu2{
//子类的成员变量名称和父类的成员变量名称不一致
int num2 = 200 ;
}
//测试类
public class ExtendsDemo2 {
public static void main(String[] args) {
//创建子类对象
//情况1:
Zi2 zi = new Zi2() ;
System.out.println(zi.num);
System.out.println(zi.num2);
}
}
* 情况2:
* 子类继承父类,子类的成员变量名称和父类的成员变量名称一致的情况:
* 一句话:遵循 "就近原则"
* 1)现在子类的局部位置中找,如果存在,就使用
* 2)如果不存在,那么就在子类的成员位置中找,如果存在,就使用
* 3)如果子类的成员位置中不存在,那么就在父类的成员位置中找,如果存在,就使用;
* 4)如果父类的成员位置中不存在,那么就报错了,压根不存在这个变量
class Fu2{
//父类的成员变量
int num = 100 ;
}
//定义一个子类
class Zi2 extends Fu2{
//成员方法
public void show(){
//子类的局部位置
int num = 30 ;
System.out.println(num) ;
}
}
//测试类
public class ExtendsDemo2 {
public static void main(String[] args) {
//情况2:
//创建子类对象
Zi2 zi = new Zi2() ;
zi.show() ;
}
}
6)注意事项:
最基本的注意事项:
1)子类继承父类,只能继承父类非私有的成员,私有的成员可以间接通过公共访问访问!
因为私有成员,只能在本类访问,外界类不能访问!
class Fu{
//父类有两个成员:公共的/私有的
public int num = 40 ;
private int num2 = 100 ;
//提供一个公共的成员方法
public void method(){
System.out.println(num2);
}
//私有的成员方法
private void function(){
System.out.println("function Fu...");
}
//公共的方法
public void function2(){
function();
}
}
//子类
class Zi extends Fu{
//定义一个成员方法
public void show(){
//展示数据
System.out.println(num);
// System.out.println(num2);//num2变量私有的
}
}
//测试类
public class ExtendsDemo1 {
public static void main(String[] args) {
//创建子类对象
Zi z = new Zi() ;
z.show() ;
z.method();
//z.function() ;//function方法 private 修饰了
z.function2();
}
}
2)子类继承父类,不能继承父类的构造方法,但是可以通过super访问(super重点关键字)
如何访问:
* 子类的所有构造方法都要(默认)访问父类的无参构造方法
* 因为存在继承关系,子类的构造方法可能会用到父类的数据,所以需要让父类先初始化(构造方法),然后子类在进行初始化
* ---->分层初始化
*
* 在子类的所有构造方法中第一句话:super() ; 访问父类的无参构造方法
//定义一个父类
class Fu {
//先提供父类的无参构造方法
public Fu(){
System.out.println("Fu的无参构造方法...") ;
}
}
//定义一个子类
class Zi extends Fu{
//子类的无参构造方法
public Zi(){
//super(); //可以省略不写,默认的!
System.out.println("Zi的无参构造方法...") ;
}
//提供子类的有参构造方法
public Zi(String name){
//super() ;//可以省略不写,默认的!
System.out.println("Zi的有参构造方法...");
}
}
//测试类
public class ExtendsDemo1{
public static void main(String[] args) {
//创建子类对象
Zi zi = new Zi() ;
System.out.println("----------------------------") ;
Zi zi2 = new Zi("hello") ;
}
}
结果:
Fu的无参构造方法...
Zi的无参构造方法...
----------------------------
Fu的无参构造方法...
Zi的有参构造方法...
2)this和super的区别
* super:代表父类的空间标识(父类对象的地址值引用) * this:代表当前类对象的地址值引用 * * 访问区别 * 访问成员变量: * this.变量名 :访问当前类的成员变量 * super.变量名;访问的父类的成员变量 * * 访问构造方法: * this() ; 访问当前类的无参构造方法 * super() ; 访问的是父类的无参构造方法 * * this(xx) ; 访问的是当前类的有参构造方法 * super(xx) ; 访问的是父类的有参构造方法 * * 访问成员方法 * this.方法名() ; 访问的是当前类的成员方法 * super.方法名() ;访问的是父类的成员方法
3)final关键字:
a)概念:
最终的,无法更改的(状态修饰符)
b)案例:
需求:
* 有一个父类,父类中有一个show方法,子类继承父类,将show方法进行复写(重写)
*但是有的时候,父类的功能不能让子类覆盖,Java提供了关键字:final
*/
//父类
class Fu{
public final void show(){
System.out.println("这是一个绝密文件,任何不得更改...") ;
}
}
//子类
class Zi extends Fu{
//重写
}
//测试类
public class FinalDemo {
public static void main(String[] args) {
//创建子类对象
Zi zi = new Zi() ;
zi.show() ;
}
}
3)特点:
* 1)可以修饰类,该类不能被继承,它不能在进行扩展了...
* 举例:后面常用类中重要的类String: 被final修饰
* 2)可以修饰变量,此时这个变量是一个常量:自定义常量
*
* 3)可以修饰成员方法,此时这个方法不能被重写
***了解***
final的应用场景 (扩展)
* 自定义常量使用居多;
* final会结合static一块使用(static修饰:可以类名直接调用)
*
* public static final int num = 100 ; //修饰基本数据类型 :编译时期常量 (Jvm不需要加载)
*
* //Integer:int类型的包装类类型(引用类型)
* public static final Integer i = new Integer() ;//修饰的引用数据类型 :运行时期常量(JVM需要加载类)
*
*
4)注意****
被final修饰的变量:只能赋值一次,不能在赋值!常量,常驻内存.
