1.final关键字
①final修饰的类不能被继承
②final修饰的方法不能被重写
③final修饰的变量不能被修改
1.final关键字修饰类
一个类被final修饰关键字修饰后，该类将不可以被继承，也就不能够派生出子类。
例子：
//使用final关键字修饰Animal类
final class Animal{
//方法为空
}
class Dog extends Animal{
//方法为空
}
class s1{
public static void main(String[]args){
Dog dog=new Dog(); //创建Dogl类的实例对象
}
}
输出：
Exception in thread "main" java.lang.Error: 无法解析的编译问题：
类型 Dog 不能成为终态类 Animal 的子类
at Dog.<init>( s1.java:6)
at s1.main( s1.java:12)
★：被final关键字修饰的类为最终类，不能被其他类继承。
2.final关键字修饰方法
一个类的方法被final修饰关键字修饰后，这个类的子类将不能重写该方法。所以想要一个父类的方法不被重写，可以使用final关键字修饰父类方法
例子：
class Animal{
//使用final关键字修饰shout类
public final void shout(){
//程序代码
}
}
class Dog extends Animal{
//重写Animal类的shout()方法
public void shout (){
//程序代码
}
}
//定义测试类
class s1{
public static void main(String[]args){
Dog dog=new Dog(); //创建Dog类的实例对象
}
}
★：方法被final关键字修饰后，子类将不能对该方法进行重写，否则编译器会报错。
3.final关键字修饰变量
一个类的变量被final修饰关键字修饰后，这个类的子类将不能修改该变量。所以想要一个变量的方法不被修改，可以使用final关键字修饰父类的变量即可。
例子：
class student {
final String name ; //使用final关键字修饰name属性
//定义inter方法，打印学生信息
public void inter(){
System. out.println("我是一名学生，我叫" +name );
}
}
public class s1{
public static void main(String[]args){
final int i=5; //第一次赋值
i=50; //第二次赋值
student stu= new student();
stu.inter();
}
}
输出：
Exception in thread "main" java.lang.Error: 无法解析的编译问题：
不能对终态局部变量 i 赋值。它必须为空白，并且不使用复合赋值
at s1.main( s1.java:12)
删去第二次赋值的代码后输出：
Exception in thread "main" java.lang.Error: 无法解析的编译问题：
空白终态字段 name 可能尚未初始化
at student.<init>( s1.java:1)
at s1.main( s1.java:13)
定义name变量同时赋值后输出：
我是一名学生，我叫小明
★：
被final关键字修饰后的变量变为常量，只能被赋值一次，其值不可改变。
使用final关键字修饰成员变量时，虚拟机不会对其进行初始化，所以在使用final关键字修饰成员变量时要在定义变量的同时赋予一个初值。
2.类的继承
1.继承的概念
是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有可继承的属性和方法。
例子：
//定义父类
class Animal {
String name; //定义name属性
//定义动物叫的方法
void shout(){
System. out.println("动物发出叫声" );
}
}
//定义Dog继承Animal类
class Dog extends Animal{
public void printName(){
System. out.println("name=" +name );
}
}
//定义测试类
public class s1{
public static void main(String[]args){
Dog dog= new Dog(); //创建一个Dog类的实例对象
dog. name="小狗狗" ; //为Dog类的name属性进行赋值
dog.printName(); //调用Dog类的printName方法
dog.shout(); //调用Dog类的继承来的shout()方法
}
}
输出:
name=小狗狗
动物发出叫声
★：
1.一个类只能有一个直接父类，类只允许单继承，不允许多重继承。
2.一个类的父类可以再去继承别的类，允许多层继承。
3.多个类可以继承同一个父类。
2.重写父类方法
在子类中需要对继承的方法进行一些修改，对父类的方法进行重写，子类重写的方法需要和父类被重写的方法具有相同的方法和方法名，参数列表和返回值类型。
例子：
//定义父类
class Animal {
String name; //定义name属性
//定义动物叫的方法
void shout(){
System. out.println("动物发出叫声" );
}
}
//定义Dog继承Animal类
class Dog extends Animal{
void shout(){ //重写shout方法
System. out.println(name +"汪汪叫" );
}
}
//定义测试类
public class s1{
public static void main(String[]args){
Dog dog= new Dog(); //创建一个Dog类的实例对象
dog. name="小狗狗" ; //为Dog类的name属性进行赋值
dog.shout(); //调用Dog类的继承来的shout()方法
}
}
★：
重写方法后，该方法被调用时只会调用重写的方法，不会调用父类的方法。
3.super关键字
用于在重写方法后，调用父类的成员变量，成员方法，构造方法
①调用父类的成员变量 super.成员变量
②调用父类的成员方法 super.成员方法(参数1,参数2,...)
例子：
//定义父类
class Animal {
String name="大狗狗" ; //定义name属性
//定义动物叫的方法
void shout(){
System. out.println("动物发出叫声" );
}
}
//定义Dog继承Animal类
class Dog extends Animal{
String name="小狗狗" ; //重写父类成员变量
void shout(){
super.shout(); //访问父类的成员方法
System. out.println(super.name+"发出叫声"); //访问父类的成员变量
}
public void printName(){
System. out.println("name=" +name );
}
}
//定义测试类
public class s1{
public static void main(String[]args){
Dog dog= new Dog(); //创建一个Dog类的实例对象
dog.printName(); //调用Dog类的printName方法
dog.shout(); //调用Dog类的继承来的方法
}
}
输出：
name=小狗狗
动物发出叫声
大狗狗发出叫声
③调用父类的构造方法 super(参数1,参数2,...)
例子：
//定义父类
class Animal {
//定义有参的构造方法
public Animal(String name){
System. out.println("这是一只" +name);
}
}
class Dog extends Animal{
public Dog(){
super("沙皮狗" ); //调用父类哟参的构造方法
}
}
public class s1{
public static void main(String[]args){
Dog dog=new Dog(); //实例化子类Dog对象
}
}
输出：
这是一只沙皮狗
★：通过spuer调用父类构造方法的代码必须位于子类构造方法的第一行，并且这能出现一次。
在子类的构造方法中一定会调用父类的某个构造方法，这时可以在子类的构造方法中通过super指定调用父类的那个构造方法，如果没有指定，在实例化子类对象时，会自动调用父类无参的构造方法，所以在定义一个类时，如无特殊需求，尽量在类中定义一个无参的构造方法，避免继承是出现错误。
3.抽象类和接口
1.抽象类：
在定义一个类时，常需要定义一些方法来描述该类的行为特征，但有时这些方法的实现方法是无法确定的。Java允许在定义方法时不写方法体，不包含方法体的方法为抽象方法，抽象方法必须使用abstract关键字修饰，当一个类中包含了抽象方法，该类就必须用abstract关键字修饰，使用abstract关键字修饰的类为抽象类。
例子：
//定义抽象类
abstract class aa{
//定义抽象方法
abstract void shout();
}
//定义dog类继承抽象类aa
class dog extends aa{
void shout(){
//定义抽象方法shout（）
System. out.println("汪汪......" );
}
}
//定义测试类
public class s2{
public static void main(String[]args){
dog gou= new dog(); //创建dog类的实例对象
gou.shout(); //调用dog对象的shout（）方法
}
}
输出结果：
汪汪.......
★：1.包含抽象方法的类必须声明为抽象类
2.抽象类可以不包含任何抽象方法，只需使用abstract关键字修饰即可。
3.抽象类时不可以被实例化的。
1.接口：
在定义一个抽象类时，这个类里所有的方法都是抽象的，就可以将这个类用灵位一种方法来定义，即接口。定义接口使用interface关键字来声明。并用implements关键字实现接口中所有的方法。
在接口中定义的方法默认使用一些修饰符来修饰，接口中的方法默认使用“public abstract”来修饰，即抽象方法，接口中变量默认使用"public static final"来修饰，即全局常量。
例子：
//定义Animal接口
interface Animal{
int ID =1;
void breathe();
void run();
}
//演示一个接口继承另一个街口
interface lan extends Animal{
void live();
}
//dog类实现了Animal接口
class Dog implements lan{
//实现breathe（）方法
public void breathe(){
System. out.println("狗在呼吸" );
}
//实现run（）方法
public void run(){
System. out.println("狗在跑" );
}
//实现live（）方法
public void live(){
System. out.println("狗生活在陆地上" );
}
}
public class s3{
public static void main(String[]args){
Dog dog= new Dog(); //创建Dog类的实例对象
dog.live();
dog.breathe(); //调用Dog类的breathe（）方法
dog.run(); //调用Dog类的run（）方法
}
}
输出:
狗生活在陆地上
狗在呼吸
狗在跑
★： 1.由于接口中的方法都是抽象方法，所以不能通过实例化对象的方式来调用接口中的方法，需要定义一个类并实现接口里的所有方法。
2.在程序中，可以定义一个接口使用extends关键字去继承另一个接口.
3.当一个类实现接口时，如果这个类是抽象类，则实现接口中的部分方法即可，否则要实现接口中的所有方法。
4.一个类通过implements关键字实现接口时，可以一次性实现多个接口，被实现的多个接口之间要用逗号隔开。
5.一个接口可以通过extends关键字继承多个接口，接口之间要用逗号隔开。
6.一个类在继承一个类的同时还可以实现接口，但extends关键字必须位于implements关键字前。
4.多态
1.多态概述
在设计一个方法时，通常希望该方法具备一定的通用性。就像要实现一个动物叫的方法，每种动物叫声不同，传入不同的的动物对象时执行发出不同的叫声的方法，在同一个方法在，这种由于参数类型不同而导致执行效果不同的现象就是多态。java中为了实现多态，允许使用一个父类类型的变量来引用一个子类类型的对象，根据被引用子类对象的特征不同，得到不同的运行结果。
实例：
//定义接口Animal
interface Animal{
void shout();
}
//定义cat类实现Animal接口
class cat implements Animal{
public void shout(){
System. out.println("猫叫" );
}
}
//定义dog类实现Animal接口
class dog implements Animal{
public void shout(){
System. out.println("狗叫" );
}
}
//定义测试类
public class s16{
//定义一个静态的方法接收Animal类型的参数
public static void ann(Animal an){
an.shout(); //调用实际参数的shout（）方法
}
public static void main(String[]agrs){
Animal an1= new cat(); //创建cat对象，使用Animal类型的变量an1引用
Animal an2= new dog(); //创建dig对象，使用Animal类型的变量an2引用
ann(an1); //调用ann（）方法，将an1作为参数传入
ann(an2); //调用ann（）方法，将an2作为参数传入
}
}
结果：
猫叫
狗叫
★：在实例中实现了父类类型变量引用不同的子类对象，当调用ann（）方法时，将父类引用的两个不同的子类对象分别传入，结果打印出猫叫和狗叫，由此可见，多态不仅解决了方法同名的问题，而且还使程序变得更加灵活，从而有效地提高程序的可扩展性和可维护性。
浙公网安备 33010602011771号