​

活动地址：CSDN21天学习挑战赛

学习内容：

• 掌握继承的基本概念及实现。
• 掌握继承实现的各种限制。
• 掌握子类对象的实例化过程。
• 掌握方法覆写的概念及实现。
• 掌握super关键字的作用。
• 掌握抽象类与接口的基本概念及实际应用。

1、继承

（1）基本概念

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

💧类的继承格式：

class 父类{ / /定义父类
    …
}
class 子类 extends 父类{ / /使用extends关键字实现继承
    …
}

继承的作用：

• 快速创建新的类;
• 实现代码的重用;
• 提高程序的可维护性;
• 节省大量创建新类的时间，提高开发效率和开发质量。

说明：

• 只允许多层继承，而不能多重继承。
• 子类可以调用父类中的非私有方法，但是不能直接调用父类中的私有成员，通过setter或getter 方法调用，则可以访问。

（2）子类对象的实例化

子类对象在实例化之前必须首先调用父类中的构造方法后再调用子类自己的构造方法。

💧范例：

class Person
{
    String name ;
    int age ;  
    public Person() // 父类的构造方法
    {
        System.out.println("父类Person中的构造") ;
    }
}
class Student extends Person
{
    String school ;  
    public Student() // 子类的构造方法
    {
        super() ;   //加与不加此语句效果相同
        System.out.println("子类Student中的构造");
    }
}
public class Demo{
   public static void main(String[] args){
      Student s = new Student() ;
   }
}

💧运行结果：

父类Person中的构造
子类Student中的构造

（3）方法的覆写

所谓的方法覆写就是指子类定义了与父类中同名的方法，但是在方法覆写时必须考虑到权限，即被子类覆写的方法不能拥有比父类方法更加严格的访问权限。

💧范例：

Class Person{
	void print() {	//定义一个默认访问权限的方法
	  System.out.println("Person-->void print(){ }");
	}
}
class Student extends Person{	//定义一个子类继承Person类
	  public void print() {	   //覆写父类中的方法，扩大了权限
        System.out.println ("Student-->void print() { }");
    }
}
public class Demo { 
   public static void main (String[] args){
    new Student().print(); //此处执行的是被覆写过的方法
   }
}

💧运行结果：

Student - - > void print() { }

• Student子类定义了与Person父类中同名的方法，但是在子类中此方法的访问权限被扩大了，符合覆写的概念，当方法被覆写之后，子类对象调用的将是被覆写后的方法。

• 如果被子类覆写的方法权限缩小，则在编译时将出现错误提示。

如果要在子类的方法中访问父类的方法，则使用super关键字即可,调用格式如下：

super.方法名（）;

• 方法覆写时从private变为default不算是方法覆写。

💧方法的重载与覆写的区别：

• 属性的覆盖，主要就是指在子类中声明了与父类同名的属性。

（4）super关键字

作用：调用父类中指定的构造方法。

this与super的区别：

注意：

• this和 super都可以调用构造方法，那么两者是不可以同时出现的，因为两者调用构造时都必须放在构造方法的首行。
• 无论子类如何操作，最终必须要先调用父类中的构造方法。

2、final关键字

final在Java中表示的意思是最终的意思。也可以称为完结器。可以使用final关键字声明类、属性、方法，在声明时需要注意以下几点：

• 使用final声明的类不能有子类；

• 使用final声明的方法不能被子类所覆写；

• 使用final声明的变量即成为常量，常量不可以修改。

final变量的命名规则：在使用final声明变量时，要求全部的字母大写，如INFO。

全局常量：使用static final关键字联合声明的变量称为全局常量，如：pubilc static final String INFO = “JAVA”;

3、抽象类的基本概念

除了继承机制外，在Java中也可以创建一种类专门用来当作父类，这种类称为“抽象类”。

抽象类的作用类似“模板”，其目的是要设计者依据它的格式来修改并创建新的类。但是并不能直接由抽象类创建对象，只能通过抽象类派生出新的类，再由它来创建对象。

抽象类在使用中同样存在单继承的局限，即一个子类只能继承一个抽象类。

💧抽象类的定义及使用规则如下：

• 包含一个抽象方法的类必须是抽象类。
• 抽象类和抽象方法都要使用abstract关键字声明。
• 抽象方法只需声明而不需要实现。
• 抽象类必须被子继承，子类（如果不是抽象类）必须覆写抽象类中的全部抽象方法。

💧抽象类的定义格式：

abstract class 抽象类名称{
   属性；
   访问权限 返回值类型 方法名称（参数）{ / /普通方法
       [return返回值]
    }
   访问权限 abstract 返回值类型 方法名称(参数) ;/ /抽象方法,没有方法体
}

注意：

• 抽象类不能使用final关键字声明
• 使用abstract关键字修饰抽象方法时不能使用private修饰

4、接口

（1）基本概念

接口可以被理解为一种特殊的类，是由全局常量和公共的抽象方法所组成。

💧接口的定义格式：

interface 接口名称{
  全局常量;// [public] [static] [final] String str=“张三”;
  抽象方法;// [public] [abstract] void print();
}

在接口中的抽象方法必须定义为public访问权限（可不写）。

与抽象类一样，接口若要使用也必须通过子类，子类通过implements关键字实现接口。

（2）实现接口

💧定义格式：

class 子类 implements 接口A，接口B，…{
}

💧范例：

interface A{           // 定义接口A
       String AUTHOR = "JAVA" ;      // 全局常量
       void print() ;       // 抽象方法
       String getInfo() ; // 抽象方法
}
abstract class B implements A{     // 定义抽象类B，实现接口A
       public abstract void say() ;    // 定义抽象方法
}
class X extends B{  // X类线继承B类
       public void say(){
              System.out.println("Hello World!!!") ;
       }
       public String getInfo(){
              return "HELLO" ;
       }
       public void print(){
              System.out.println("作者：" + AUTHOR) ;
       }
}
public class InterfaceDemo{
       public static void main(String[] args){
              X x = new X() ;     // 实例化子类对象
              x.say() ;
              x.print() ;
       }
}

💧运行结果：

Hello World!!!
作者：JAVA

（3）继承抽象类实现接口

💧定义格式：

class 子类 extends 抽像类 implements 接口A,接口B,…{
}

（4）接口的继承

💧定义格式：

interface 子接口 extends 父接口A,父接口B,…{
}