接口、多态、内部类、final和static关键字(温习知识点)

璃尔 °

已于 2022-07-14 10:51:31 修改

阅读量90

点赞数

分类专栏： Java编程入门文章标签： java

于 2021-06-28 19:36:18 首次发布

本文链接：https://blog.csdn.net/qq_43492477/article/details/118281491

版权

Java编程入门专栏收录该内容

42 篇文章 0 订阅

订阅专栏

今日内容

* 接口【理解】
	* 什么是接口【理解】
	* 接口的定义格式【掌握】
	* 接口的使用【掌握】
	* 接口成员的特点【理解】
	* 类和接口 抽象类和接口之间的关系【理解】
	* 单继承多实现【掌握】
	* 接口之间的多继承【理解】
* 多态
	* 什么是多态【理解】 
	* 使用多态的前提【理解】
	* 多态的格式【掌握】
	* 多态中的好处和弊端【理解】
	* 多态中的转型【理解】
	* 转型的异常【理解】
	* instancrof使用格式【掌握】
* 内部类
	* 什么是内部类【理解】
	* 内部类的分类【理解】
	* 匿名内部类【掌握】
* final关键字【理解】
	* final概述
	* final关键字的使用【理解】
	* final是否可以和abstract关键字一起使用
* static关键字【掌握】
	* static概念 
	* static关键字的使用【掌握】
	* 注意事项
	* 静态代码块【掌握】
* 引用类型作为方法的参数和返回值【掌握】
	* class作为方法的参数及返回值
	* 抽象类作为方法的参数及返回值
	* 接口作为方法的参数及返回值
* 包的定义及规范【理解】
	* 包的概念
	* 包的注意事项
	* 类与类的访问
* 权限修饰符【理解】
	* 分类
	* 不同权限的访问范围

一、接口

01.什么是接口

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法（功能），包含抽象方法 (JDK7及以前) , 默认方法和静态方法（JDK8）私有方法（JDK9）。
可以理解为大量抽象方法的抽象。

02.接口的定义格式

接口用关键字interface修饰

		public interface 接口名 {}

03.接口的使用

接口是不能创建对象，必须有实现类才能使用，类实现接口用implements表示

		public class 类名 implements 接口名 {}

用于实现接口的类称之为实现类,实现类必须实现所实现接口的所有抽象方法，否则需要定义为抽象类。

04.接口成员的特点

成员变量
只能是常量，默认修饰符：public static final
成员方法
只能是抽象方法，默认修饰符：public abstract
构造方法
没有，因为接口主要是扩展功能的，而没有具体存在

05.类和接口抽象类和接口之间的关系

类和接口的关系

类与类的关系
继承关系，只能单继承，但是可以多层继承
类与接口的关系
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
接口与接口的关系
继承关系，可以单继承，也可以多继承

抽象类和接口的区别

语法区别： 抽象类使用abstract关键字修饰class 接口使用interface关键字创建
成员变量区别： 抽象类可以书写任意变量，接口中只能书写静态常量
成员方法区别： 抽象类中既可以书写实现方法也可以书写抽象方法，接口中只能拥有抽象方法
修饰符区别： 抽象类中修饰符与类的修饰符默认书写一致，接口中方法修饰符默认为public abstract
构造方法区别： 抽象类中可以书写构造方法，由子类调用进行赋值，接口中不能书写构造方法
关系区别： 类与类之间只存在单继承关系，类与接口存在多实现关系，接口与接口可以多继承
设计理念区别： 抽象类为了继承而来，让子类强制重写父类中的抽象方法，接口是对行为抽象，主要是行为的集合。

06.单继承多实现

在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。

接口中，有多个抽象方法时，实现类必须重写所有抽象方法。
如果实现类继承了父类，这个父类是一个抽象类时，我们还需要再重写抽象类中的所有抽象方法。

		//多实现格式
		class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {    
   	 		// 重写接口中抽象方法【必须】
    		// 重写接口中默认方法【不重名时可选】
		}

07.接口之间的多继承

一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用extends关键字，子接口继承父接口的方法。如果父接口中的默认方法有重名的，那么子接口需要重写一次。

		public interface 接口名 extends 接口名1,接口名2，接口名3 {}

接口多继承之后，如果想使用，我们还必须定义实现类，才能使用

二、多态

01.什么是多态

一个父类不同的子类形态,根据不同的形态决定代码的调用与执行。
多态是同一个行为具有多个不同表现形式或形态的能力。

02.使用多态的前提

子类继承父类或实现类实现接口
方法重写
向上转型（声明父类变量保存子类对象）

03.多态的格式

普通类多态的格式
父类对象 = new 子类();
抽象类多态的格式
抽象类对象名 = new 抽象类子类();
接口多态的格式
接口对象名 = new 接口实现类();

04.多态中的好处和弊端

优点
减少代码书写，增强可维护性与扩展性
缺点
不能使用子类特有的属性与方法（只能使用父类的属性与方法）

05.多态中的转型

向上转型

声明父类变量,保存子类对象，类似于java的自动类型转换

向下转型

一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。
声明子类变量,保存父类声明对象变量，类似于java的强制类型转换，需要书写额外语法
向下转型成功的前提（曾经发生过向上转型并且与转型类型相同）

06.转型的异常

		public class Test {
    		public static void main(String[] args) {
        		// 向上转型  
        		Animal a = new Cat();  
        		a.eat();               // 调用的是 Cat 的 eat
 
        		// 向下转型  
        		Dog d = (Dog)a;       
        		d.watchHouse();        // 调用的是 Dog 的 watchHouse 【运行报错】    	
        	}  
		}

这段代码可以通过编译，但是运行时，却报出了ClassCastException类型转换异常！这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。

为了避免 ClassCastException 的发生，Java提供了instanceof关键字，给引用变量做类型的校验，格式如下：

public class Test {
    public static void main(String[] args) {
        // 向上转型  
        Animal a = new Cat();  
        a.eat();               // 调用的是 Cat 的 eat

        // 向下转型  
        if (a instanceof Cat){
            Cat c = (Cat)a;       
            c.catchMouse();        // 调用的是 Cat 的 catchMouse        
        } else if (a instanceof Dog){
            Dog d = (Dog)a;       
            d.watchHouse();       // 调用的是 Dog 的 watchHouse
        }
    }  
}

07.`instanceof`使用格式

变量名 instanceof 数据类型 
    如果变量属于该数据类型，返回true。
    如果变量不属于该数据类型，返回false。

三、内部类

01.什么是内部类

在一个类的内部书写另一个类。
将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

02.内部类的分类

同级类
严格意义来讲不算内部类，只不过是在同一个.java中定义多个类
成员内部类
在一个类类体中定义另一个类，将定义类的当做是类的成员
局部内部类
在一个类的方法中定义一个类
匿名内部类
创建具有实现方法的无名称的类

03.匿名内部类

概念

是一种特殊的局部类，在进行创建实现类或子类时，如果创建的类只使用一次，则可以使用匿名内部类的形式进行书写

书写

匿名内部类必须 继承一个父类 或者 实现一个父接口。

		new 父类名或者接口名(){
    		// 方法重写
    		@Override 
    		public void method() {        // 执行语句
    		}
		};

在使用实现类或子类，无需创建指定的子类与实现类，可以通过父类或接口直接使用new匿名内部类的形式创建一个临时使用的子类或实现类，创建对象并进行使用

四、final关键字

01.`final`概述

final： 最终的、不可修改的。用于修改不同的位置实现不同的功能，主要修饰类、方法和变量。

02.final关键字的使用

修饰类

在类关键字class之前书写final关键字修饰当前类，使当前类变为最终的类（不能继承）

		final class 类名 {  
		}

修饰方法

如果方法使用final修饰代表这个方法为最终方法不允许被修改（可以被继承不能被重写）

		修饰符 final 返回值类型 方法名(参数列表){    
    		//方法体
		}

修饰变量

变量保存的是地址，被final修饰的变量称之为常量（变量保存的地址不能修改）

局部变量———基本类型
基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。
与变量的使用没有区别，也可以先声明，之后进行赋值后不能更改
可以理解为被final修饰的变量会保存第一次赋值的地址并且不允许进行更改
局部变量———引用类型
引用类型变量使用final修饰与基本数据类型一样，保存在栈中的地址不允许修改，但是引用类型栈中保存的是相应对象堆中的地址，相应对象属性保存其他地址是可以修改的
成员变量
因为在创建对象时，成员变量涉及到初始化，被final修饰的变量只能赋值，如果初始化时使用默认值进行赋值，则不能修改，导致无意义,所以，在使用final关键字修饰全局变量时必须进行初始化赋值.