2021年最新Java基础入门篇(5)

最新推荐文章于 2023-04-13 16:54:16 发布

zhangyuxin0326

最新推荐文章于 2023-04-13 16:54:16 发布

阅读量610

点赞数

分类专栏：笔记个人学习文章标签： java 后端

原文链接：https://blog.csdn.net/qq_42586468/article/details/104080916

版权

笔记同时被 2 个专栏收录

15 篇文章 0 订阅

订阅专栏

个人学习

14 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的继承、抽象类和接口的基础概念及用法。通过实例展示了继承的格式、特点，包括成员变量、成员方法、构造方法的处理。接着讲解了抽象类的定义、使用及其注意事项。接口部分涵盖了定义、实现、多实现、多继承以及静态和默认方法的使用。此外，还讨论了多态的概念、好处以及类型转换的规则。最后提到了final关键字和权限修饰符的作用。

摘要由CSDN通过智能技术生成

2021年最新Java基础入门篇(5)

第五篇来了来了~~~~

前言

话不多说直接上干货

一、继承

1.1 定义

继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

好处

提高代码的复用性。
类与类之间产生了关系，是多态的前提。

1.2 继承的格式

通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：

// 格式
class 父类 {
	...
}
class 子类 extends 父类 {
	...
}

/*
* 定义员工类Employee，做为父类
*/
class Employee {
	String name; // 定义name属性
	// 定义员工的工作方法
	public void work() {
		System.out.println("尽心尽力地工作");
	}
}
/*
* 定义讲师类Teacher 继承 员工类Employee
*/
class Teacher extends Employee {
	// 定义一个打印name的方法
	public void printName() {
		System.out.println("name=" + name);
	}
}
/*
* 定义测试类
*/
public class ExtendDemo01 {
	public static void main(String[] args) {
		// 创建一个讲师类对象
		Teacher t = new Teacher();
		// 为该员工类的name属性进行赋值
		t.name = "小明";
		// 调用该员工的printName()方法
		t.printName(); // name = 小明
		// 调用Teacher类继承来的work()方法
		t.work(); // 尽心尽力地工作
	}
}

1.3 继承后的特点——成员变量

当类之间产生了关系后，其中各类中的成员变量，又产生了哪些影响呢？

成员变量不重名

如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。代码如下：

class Fu {
	// Fu中的成员变量。
	int num = 5;
}
class Zi extends Fu {
		// Zi中的成员变量
		int num2 = 6;
		// Zi中的成员方法
		public void show() {
		// 访问父类中的num，
		System.out.println("Fu num="+num); // 继承而来，所以直接访问。
		// 访问子类中的num2
		System.out.println("Zi num2="+num2);
	}
}
class ExtendDemo02 {
public static void main(String[] args) {
		// 创建子类对象
		Zi z = new Zi();
		// 调用子类中的show方法
		z.show();
	}
}
演示结果：
Fu num = 5
Zi num2 = 6

成员变量重名

如果子类父类中出现重名的成员变量，这时的访问是有影响的。代码如下：

class Fu {
	// Fu中的成员变量。
	int num = 5;
}
class Zi extends Fu {
	// Zi中的成员变量
	int num = 6;
	public void show() {
		// 访问父类中的num
		System.out.println("Fu num=" + num);
		// 访问子类中的num
		System.out.println("Zi num=" + num);
	}
}
class ExtendsDemo03 {
	public static void main(String[] args) {
		// 创建子类对象
		Zi z = new Zi();
		// 调用子类中的show方法
		z.show();
	}
}
演示结果：
Fu num = 6
Zi num = 6

子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字，修饰父类成员变量，类似于之前学过的this

// 格式
// super.父类成员变量名
// 示例
class Zi extends Fu {
	// Zi中的成员变量
	int num = 6;
	public void show() {
		//访问父类中的num
		System.out.println("Fu num=" + super.num);
		//访问子类中的num
		System.out.println("Zi num=" + this.num);
	}
}
演示结果：
Fu num = 5
Zi num = 6

Fu 类中的成员变量是非私有的，子类中可以直接访问。若Fu 类中的成员变量私有了，子类是不能直接访问的。
通常编码时，我们遵循封装的原则，使用private修饰成员变量，那么如何访问父类的私有成员变量呢？
对！可以在父类中提供公共的getXxx方法和setXxx方法。

1.4 继承后的特点——成员方法

当类之间产生了关系，其中各类中的成员方法，又产生了哪些影响呢？

成员方法不重名
如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对
应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。代码如下：

class Fu{
	public void show(){
		System.out.println("Fu类中的show方法执行");
	}
}
class Zi extends Fu{
	public void show2(){
		System.out.println("Zi类中的show2方法执行");
	}
}
public class ExtendsDemo04{
	public static void main(String[] args) {
		Zi z = new Zi();
		//子类中没有show方法，但是可以找到父类方法去执行
		z.show();
		z.show2();
	}
}

成员方法重名——重写(Override)
如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写 (Override)。
方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

class Fu {
	public void show() {
		System.out.println("Fu show");
	}
}
class Zi extends Fu {
	//子类重写了父类的show方法
	public void show() {
		System.out.println("Zi show");
	}
}
public class ExtendsDemo05{
	public static void main(String[] args) {
		Zi z = new Zi();
		// 子类中有show方法，只执行重写后的show方法
		z.show(); // Zi show
	}
}

重写的应用
子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从而进行扩展增强。比如新的手机增加来电显示头像的功能，代码如下

class Phone {
	public void sendMessage(){
		System.out.println("发短信");
	}
	public void call(){
		System.out.println("打电话");
	}
	public void showNum(){
		System.out.println("来电显示号码");
	}
}
//智能手机类
class NewPhone extends Phone {
	//重写父类的来电显示号码功能，并增加自己的显示姓名和图片功能
	public void showNum(){
		//调用父类已经存在的功能使用super
		super.showNum();
		//增加自己特有显示姓名和图片功能
		System.out.println("显示来电姓名");
		System.out.println("显示头像");
	}
}
public class ExtendsDemo06 {
	public static void main(String[] args) {
		// 创建子类对象
		NewPhone np = new NewPhone()；
		// 调用父类继承而来的方法
		np.call();
		// 调用子类重写的方法
		np.showNum();
	}
}

tips:
	这里重写时，用到super.父类成员方法，表示调用父类的成员方法
注意事项：
	1. 子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
	2. 子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。

1.5 继承后的特点——构造方法

当类之间产生了关系，其中各类中的构造方法，又产生了哪些影响呢？

首先我们要回忆两个事情，构造方法的定义格式和作用。

构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。代码如下：

class Fu {
	private int n;
	Fu(){
		System.out.println("Fu()");
	}
}
class Zi extends Fu {
	Zi(){
		// super（），调用父类构造方法
		super();
		System.out.println("Zi（）");
	}
}
public class ExtendsDemo07{
	public static void main (String args[]){
		Zi zi = new Zi();
	}
}
输出结果：
Fu（）
Zi（）

1.6 super和this

super和this的含义

super ：代表父类的存储空间标识(可以理解为父亲的引用)。
this ：代表当前对象的引用(谁调用就代表谁)。

super和this的用法

1、访问成员

this.成员变量 ‐‐ 本类的
super.成员变量 ‐‐ 父类的
this.成员方法名() ‐‐ 本类的
super.成员方法名() ‐‐ 父类的

// 用法示例
class Animal {
	public void eat() {
		System.out.println("animal : eat");
	}
}
class Cat extends Animal {
	public void eat() {
		System.out.println("cat : eat");
	}
	public void eatTest() {
		this.eat(); // this 调用本类的方法
		super.eat(); // super 调用父类的方法
	}
}
public class ExtendsDemo08 {
	public static void main(String[] args) {
		Animal a = new Animal();
		a.eat();
		Cat c = new Cat();
		c.eatTest();
	}
}
输出结果为：
animal : eat
cat : eat
animal : eat

2、访问构造方法

this(...) ‐‐ 本类的构造方法
super(...) ‐‐ 父类的构造方法
/*
子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。
super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。
*/

1.7 继承的特点

Java只支持单继承，不支持多继承。

//一个类只能有一个父类，不可以有多个父类。
class C extends A{} //ok
class C extends A，B... //error

Java支持多层继承(继承体系)。

class A{}
class B extends A{}
class C extends B{}

子类和父类是一种相对的概念

二、抽象类

2.1 概述

定义
抽象方法 ：没有方法体的方法。
抽象类：包含抽象方法的类。

2.2 abstract使用格式

使用 abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

// 定义格式：
饰符 abstract 返回值类型 方法名 (参数列表);
// 代码举例：
public abstract void run();

抽象类
如果一个类包含抽象方法，那么该类必须是抽象类。

// 定义格式
abstract class 类名字 {
}
// 代码举例
public abstract class Animal {
	public abstract void run();
}

抽象的使用

继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。

public class Cat extends Animal {
	public void run (){
		System.out.println("小猫在墙头走~~~")；
	}
}
public class CatTest {
	public static void main(String[] args) {
		// 创建子类对象
		Cat c = new Cat();
		// 调用run方法
		c.run();
	}
}
输出结果：
小猫在墙头走~~~

此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

2.3 注意事项

抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。
抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。
抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。
理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

三、接口

3.1 概述

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法
（JDK 9）。

接口的定义，它与定义类方式相似，但是使用interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。

接口的使用，它不能创建对象，但是可以被实现（ implements，类似于被继承）。一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象
类。

3.2 定义格式

public interface 接口名称 {
	// 抽象方法
	// 默认方法
	// 静态方法
	// 私有方法
}

含有抽象方法

抽象方法：使用 abstract关键字修饰，可以省略，没有方法体。该方法供子类实现使用

public interface InterFaceName {
	public abstract void method();
}

含有默认方法和静态方法

默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。
静态方法：使用 static 修饰，供接口直接调用。
代码如下：

public interface InterFaceName {
	public default void method() {
		// 执行语句
	}
	public static void method2() {
		// 执行语句
	}
}

含有私有方法和私有静态方法

私有方法：使用private 修饰，供接口中的默认方法或者静态方法调用。
代码如下：

public interface InterFaceName {
	private void method() {
		// 执行语句
	}
}

2.3 基本的实现

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements关键字。
非抽象子类实现接口：

必须重写接口中所有抽象方法。
继承了接口的默认方法，即可以直接调用，也可以重写。
实现格式：

class 类名 implements 接口名 {
	// 重写接口中抽象方法【必须】
	// 重写接口中默认方法【可选】
}

抽象方法的使用
必须全部实现，代码如下：

// 接口
public interface LiveAble {
	// 定义抽象方法
	public abstract void eat();
	public abstract void sleep();
}

// 实现类
public class Animal implements LiveAble {
	@Override
	public void eat() {
		System.out.println("吃东西");
	}
	@Override
	public void sleep() {
		System.out.println("晚上睡");
	}
}

// 测试类
public class InterfaceDemo {
	public static void main(String[] args) {
		// 创建子类对象
		Animal a = new Animal();
		// 调用实现后的方法
		a.eat();
		a.sleep();
	}
}
输出结果：
吃东西
晚上睡

默认方法的使用
可以继承，可以重写，二选一，但是只能通过实现类的对象来调用。

继承默认方法

// 定义接口
public interface LiveAble {
	public default void fly(){
		System.out.println("天上飞");
	}
}
// 定义实现类
public class Animal implements LiveAble {
	// 继承，什么都不用写，直接调用
}
// 定义测试类
public class InterfaceDemo {
	public static void main(String[] args) {
		// 创建子类对象
		Animal a = new Animal();
		// 调用默认方法
		a.fly();
	}
}
输出结果：
天上飞

重写默认方法

// 定义接口
public interface LiveAble {
	public default void fly(){
		System.out.println("天上飞");
	}
}
// 定义实现类
public class Animal implements LiveAble {
	@Override
	public void fly() {
		System.out.println("自由自在的飞");
	}
}
// 定义测试类
public class InterfaceDemo {
	public static void main(String[] args) {
		// 创建子类对象
		Animal a = new Animal();
		// 调用重写方法
		a.fly();
	}
}
输出结果：
自由自在的飞

静态方法的使用
静态与.class 文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用，代码如下：

// 定义接口
public interface LiveAble {
	public static void run(){
		System.out.println("跑起来~~~");
	}
}
// 定义实现类
public class Animal implements LiveAble {
	// 无法重写静态方法
}
// 定义测试类
public class InterfaceDemo {
	public static void main(String[] args) {
		// Animal.run(); // 【错误】无法继承方法,也无法调用
		LiveAble.run(); //
	}
}
输出结果：
跑起来~~~

私有方法的使用

私有方法：只有默认方法可以调用。
私有静态方法：默认方法和静态方法可以调用。
如果一个接口中有多个默认方法，并且方法中有重复的内容，那么可以抽取出来，封装到私有方法中，供默认方法去调用。从设计的角度讲，私有的方法是对默认方法和静态方法的辅助。

// 定义接口
public interface LiveAble {
	default void func(){
		func1();
		func2();
	}
	private void func1(){
		System.out.println("跑起来~~~");
	}
	private void func2(){
		System.out.println("跑起来~~~");
	}
}

2.4 接口的多实现

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

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

抽象方法

接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。代码如下：

// 定义多个接口
interface A {
	public abstract void showA();
	public abstract void show();
}
interface B {
	public abstract void showB();
	public abstract void show();
}
// 定义实现类
public class C implements A,B{
	@Override
	public void showA() {
		System.out.println("showA");
	}
	@Override
	public void showB() {
		System.out.println("showB");
	}
	@Override
	public void show() {
		System.out.println("show");
	}
}

默认方法

接口中，有多个默认方法时，实现类都可继承使用。如果默认方法有重名的，必须重写一次。代码如下：

// 定义多个接口：
interface A {
	public default void methodA(){}
	public default void method(){}
}
interface B {
	public default void methodB(){}
	public default void method(){}
}
// 定义实现类：
public class C implements A,B{
	@Override
	public void method() {
		System.out.println("method");
	}
}

静态方法
接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法。

优先级的问题
当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法。代码如下

// 定义接口
interface A {
	public default void methodA(){
		System.out.println("AAAAAAAAAAAA");
	}
}
// 定义父类
class D {
	public void methodA(){
		System.out.println("DDDDDDDDDDDD");
	}
}
// 定义子类
class C extends D implements A {
	// 未重写methodA方法
}
// 定义测试类
public class Test {
	public static void main(String[] args) {
		C c = new C();
		c.methodA();
	}
}
输出结果:
DDDDDDDDDDDD

2.5 接口的多继承【了解】

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

// 定义父接口：
interface A {
	public default void method(){
		System.out.println("AAAAAAAAAAAAAAAAAAA");
	}
}
interface B {
	public default void method(){
		System.out.println("BBBBBBBBBBBBBBBBBBB");
	}
}
// 定义子接口：
interface D extends A,B{
	@Override
	public default void method() {
		System.out.println("DDDDDDDDDDDDDD");
	}
}

tips:
	子接口重写默认方法时，default关键字可以保留。
	子类重写默认方法时，default关键字不可以保留。

2.6 其他成员特点

接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰。
接口中，没有构造方法，不能创建对象。
接口中，没有静态代码块。

三、多态

3.1 概述

多态是继封装、继承之后，面向对象的第三大特性。
生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。
再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。
可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态。

定义

多态：是指同一行为，具有多个不同表现形式。

继承或者实现【二选一】
方法的重写【意义体现：不重写，无意义】
父类引用指向子类对象【格式体现】

3.2 多态的体现

前提【重点】

// 格式
父类类型 变量名 = new 子类对象；
变量名.方法名();
// 父类类型：指子类对象继承的父类类型，或者实现的父接口类型
// 演示
Fu f = new Zi();
f.method();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。

// 定义父类
public abstract class Animal {
	public abstract void eat();
}
// 定义子类
class Cat extends Animal {
	public void eat() {
		System.out.println("吃鱼");
	}
}
class Dog extends Animal {
	public void eat() {
		System.out.println("吃骨头");
	}
}
// 定义测试类
public class Test {
	public static void main(String[] args) {
		// 多态形式，创建对象
		Animal a1 = new Cat();
		// 调用的是 Cat 的 eat
		a1.eat();
		// 多态形式，创建对象
		Animal a2 = new Dog();
		// 调用的是 Dog 的 eat
		a2.eat();
	}
}

3.3 多态的好处

// 定义父类
public abstract class Animal {
	public abstract void eat();
}
// 定义子类：
class Cat extends Animal {
	public void eat() {
		System.out.println("吃鱼");
	}
}
class Dog extends Animal {
	public void eat() {
		System.out.println("吃骨头");
	}
}
// 定义测试类
public class Test {
	public static void main(String[] args) {
	// 多态形式，创建对象
	Cat c = new Cat();
	Dog d = new Dog();
	// 调用showCatEat
	showCatEat(c);
	// 调用showDogEat
	showDogEat(d);
	/*
	以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代
	而执行效果一致
	*/
	showAnimalEat(c);
	showAnimalEat(d);
	}
	public static void showCatEat (Cat c){
		c.eat();
	}
	public static void showDogEat (Dog d){
		d.eat();
	}
	public static void showAnimalEat (Animal a){
		a.eat();
	}
}

由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以把Cat对象和Dog对象，传递给方法。

当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致，所以showAnimalEat完全可以替代以上两方法。

不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用showAnimalEat都可以完成。

所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。

3.4 引用类型转换

多态的转型分为向上转型与向下转型两种：

向上转型

向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

当父类引用指向一个子类对象时，便是向上转型。

// 使用格式
父类类型 变量名 = new 子类类型();
Animal a = new Cat();

向下转型

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。
一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

// 使用格式
子类类型 变量名 = (子类类型) 父类变量名;
Cat c =(Cat) a;

为什么要转型

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。

// 定义类
abstract class Animal {
	abstract void eat();
}
class Cat extends Animal {
	public void eat() {
		System.out.println("吃鱼");
	}
	public void catchMouse() {
		System.out.println("抓老鼠");
	}
}
class Dog extends Animal {
	public void eat() {
		System.out.println("吃骨头");
	}
	public void watchHouse() {
		System.out.println("看家");
	}
}
// 定义测试类
public class Test {
	public static void main(String[] args) {
		// 向上转型
		Animal a = new Cat();
		a.eat(); // 调用的是 Cat 的 eat
		// 向下转型
		Cat c = (Cat)a;
		c.catchMouse(); // 调用的是 Cat 的 catchMouse
	}
}

转型的异常
转型的过程中，一不小心就会遇到这样的问题，请看如下代码：

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 关键字，给引用变量做类型的校验，格式如下：

// 格式
变量名 instanceof 数据类型

/*
	如果变量属于该数据类型，返回true。
	如果变量不属于该数据类型，返回false。
	所以，转换前，我们最好先做一个判断，代码如下：
*/	

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
		}
	}
}

四、 final关键字

4.1 概述

学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了 final 关键字，用于修饰不可改变内容。

final：不可改变。可以用于修饰类、方法和变量。

类：被修饰的类，不能被继承。
方法：被修饰的方法，不能被重写。
变量：被修饰的变量，不能被重新赋值。

4.2 使用方式

修饰类

// 格式
final class 类名 {}

查询API发现像 public final class String 、 public final class Math 、 public final class Scanner等，很多我们学习过的类，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容。

修饰方法

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

重写被 final 修饰的方法，编译时就会报错。

修饰变量

局部变量——基本类型
基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。代码如下：

public class FinalDemo1 {
	public static void main(String[] args) {
		// 声明变量，使用final修饰
		final int a;
		// 第一次赋值
		a = 10;
		// 第二次赋值
		a = 20; // 报错,不可重新赋值
		// 声明变量，直接赋值，使用final修饰
		final int b = 10;
		// 第二次赋值
		b = 20; // 报错,不可重新赋值
	}
}

思考: 如下两种写法，哪种可以通过编译？

//	写法1：
final int c = 0;
for (int i = 0; i < 10; i++) {
	c = i;
	System.out.println(c);
}
// 写法2：
for (int i = 0; i < 10; i++) {
	final int c = i;
	System.out.println(c);
}

根据 final 的定义，写法1报错！写法2为什么通过编译呢？因为每次循环，都是一次新的变量c。

局部变量——引用类型
引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的修改，代码如下：

public class FinalDemo2 {
	public static void main(String[] args) {
		// 创建 User 对象
		final User u = new User();
		// 创建 另一个 User对象
		u = new User(); // 报错，指向了新的对象，地址值改变。
		// 调用setName方法
		u.setName("张三"); // 可以修改
	}
}

成员变量
成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：

显示初始化；

public class User {
   final String USERNAME = "张三";
   private int age;
}

构造方法初始化

public class User {
	// 被final修饰的常量名称，一般都有书写规范，所有字母都大写。
	final String USERNAME ;
	private int age;
	public User(String username, int age) {
		this.USERNAME = username;
		this.age = age;
	}
}

五、权限修饰符

5.1 概述

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限

public：公共的。
protected：受保护的
default：默认的
private：私有的

5.2 不同权限的访问能力

在这里插入图片描述

可见，public 具有最大权限。private 则是最小权限。

编写代码时，如果没有特殊的考虑，建议这样使用权限：

成员变量使用 private ，隐藏细节。
构造方法使用 public ，方便创建对象。
成员方法使用 public ，方便调用方法。
不加访问权限修饰符，其访问能力和default修饰符相同

六、内部类

6.1 概述

什么是内部类

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

成员内部类

成员内部类：定义在类中方法外的类。

// 定义格式：
class 外部类 {
	class 内部类{
	}
}
/*
在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。
比如，汽车类 Car 中包含发动机类 Engine ，这时， Engine 就可以使用内部类来描述，定义在成员位置。
*/

class Car { //外部类
	class Engine { //内部类
	}
}

访问特点

内部类可以直接访问外部类的成员，包括私有成员。
外部类要访问内部类的成员，必须要建立内部类的对象。

//	创建内部类对象格式：
外部类名.内部类名 对象名 = new 外部类型().new 内部类型();

//定义类：
public class Person {
	private boolean live = true;
	class Heart {
		public void jump() {
			// 直接访问外部类成员
			if (live) {
				System.out.println("心脏在跳动");
			} else {
				System.out.println("心脏不跳了");
			}
		}
	}
	public boolean isLive() {
		return live;
	}
	public void setLive(boolean live) {
		this.live = live;
	}
}

// 定义测试类：
public class InnerDemo {
	public static void main(String[] args) {
		// 创建外部类对象
		Person p = new Person();
		// 创建内部类对象
		Heart heart = p.new Heart();
		// 调用内部类方法
		heart.jump();
		// 调用外部类方法
		p.setLive(false);
		// 调用内部类方法
		heart.jump();
	}
}
输出结果:
心脏在跳动
心脏不跳了

内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名
和$符号。
比如，Person$Heart.class

6.2 匿名内部类【重点】

匿名内部类 ：是内部类的简化写法。它的本质是一个 带具体实现的父类或者父接口的匿名的 子类对象。
开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，似乎得做如下几步操作，

定义子类
重写接口中的方法
创建子类对象
调用重写后的方法

我们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是做这样的快捷方式。

前提

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

// 格式
new 父类名或者接口名(){
	// 方法重写
	@Override
	public void method() {
		// 执行语句
	}
};
//  使用方式
//	以接口为例，匿名内部类的使用，代码如下：
//	定义接口：
public abstract class FlyAble{
	public abstract void fly();
}
// 创建匿名内部类，并调用：
public class InnerDemo {
	public static void main(String[] args) {
		/*
		1.等号右边:是匿名内部类，定义并创建该接口的子类对象
		2.等号左边:是多态赋值,接口类型引用指向子类对象
		*/
		FlyAble f = new FlyAble(){
				public void fly() {
					System.out.println("我飞了~~~");
				}
			};
		//调用 fly方法,执行重写后的方法
		f.fly();
	}
}
// 通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。代码如下：
public class InnerDemo2 {
	public static void main(String[] args) {
		/*
		1.等号右边:定义并创建该接口的子类对象
		2.等号左边:是多态,接口类型引用指向子类对象
		*/
		FlyAble f = new FlyAble(){
			public void fly() {
				System.out.println("我飞了~~~");
			}
		};
		// 将f传递给showFly方法中
		showFly(f);
		}
		public static void showFly(FlyAble f) {
			f.fly();
	}
}

以上两步，也可以简化为一步，代码如下：

public class InnerDemo3 {
	public static void main(String[] args) {
		/*
		创建匿名内部类,直接传递给showFly(FlyAble f)
		*/
		showFly( new FlyAble(){
			public void fly() {
				System.out.println("我飞了~~~");
			}
		});
	}
	public static void showFly(FlyAble f) {
		f.fly();
	}
}

总结

Java基础入门篇的分享到这里就结束了，如有错误请在评论区指正。
接下来会更新进阶篇内容，希望大家继续关注我哦~~~ 因为与别人写的太过相似所以不能发原创所以放上了别人的文章链接大家也可以去看看
https://blog.csdn.net/qq_42586468/article/details/104080916