Java知识点（十）：static final、抽象类、接口、多态、内部类、面向对象三大特征

已于 2023-06-13 20:27:13 修改
阅读量1.3k 收藏 3
点赞数 1
CC 4.0 BY-SA版权
分类专栏： Java知识点 文章标签： java
于 2022-04-30 08:39:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45138120/article/details/124484816
本文详细介绍了Java语言的基础知识，包括static final常量的使用，抽象类及其抽象方法，接口的定义、实现与继承，多态的概念及其实现方式，如向上造型和强制类型转换，以及内部类的分类和应用。同时，阐述了面向对象的三大特性：封装、继承和多态，强调了它们在实际编程中的重要性。

文章目录

Java语言基础

包含static final常量；什么是抽象类、抽象方法、继承抽象类、抽象类的意义；什么是接口、接口的实现、接口的继承、接口的意义、设计原则；什么是多态、向上造型、强制类型转换、instanceof；成员内部类、匿名内部类、内部类的应用；面向对象的三大特征：封装、继承、多态。

一、static final常量

1）必须声明同时初始化

2）通过类名点来访问，不能改变

3）建议：常量名所有字母都大写

4）在编译时被直接替换为具体的值，效率高

package oo.day05;
//static final常量的演示

public class StaticFinalDemo {

	public static void main(String[] args) {
		System.out.println(Aoo.PI);
		//Aoo.PI = 3.141592; //编译错误，常量不能被改变
		
		System.out.println(Boo.count); //三步：1.加载Boo.class到方法区中；2.count保存在方法区中；3.到方法区中获取count并输出
		System.out.println(Boo.NUM); //编译时自动代替为具体的值-----效率高；相当于System.out.println(5);
	}

}

class Boo{
	public static final int NUM = 5; //常量
	public static int count = 8; //静态变量
}

class Aoo{
	public static final double PI = 3.14159;
	//public static final int NUM; //编译错误，必须声明同时初始化
}

在这里插入图片描述

二、抽象类

2.1、什么是抽象类

1）由abstract关键字修饰的类称为抽象类

2）抽象类不能被实例化（不能new对象），抽象类是需要被继承的

3）抽象类为子类“抽象”出了公共部分，通常也定义了子类所必须具有实现的抽象方法

public abstract class Aoo{
	private int a;
	public void show() {
		System.out.println("抽象类");
	}
}

2.2、抽象方法

1）由abstract关键字修饰的方法

2）只有方法的定义，没有方法的实现（没有大括号）

3）包含抽象方法的类必须是抽象类，不包含抽象方法的类也可以声明为抽象类

4）用abstract修饰的方法，仅仅只有方法的定义，没有方法的实现

public abstract class Aoo{
	private int a;
	public abstract void show();
}

2.3、继承抽象类

一个类继承抽象类必须实现其抽象方法，除非该类也声明为抽象类

//重写抽象类方法-----重用
class Boo extends Aoo{
	public void show() {
		System.out.println("重写抽象类的方法");
	}
}

//声明为抽象类-----不常用
abstract class Coo extends Aoo{
	
}

2.4、抽象类的意义

1）包含公共的属性和行为，被子类所共享-----代码重用

2）为所有子类提供一种公共的类型-----向上造型

3）包含抽象方法，为所有子类提供一个统一的入口

经典案例：找一组图形中的最大面

三、接口

3.1、什么是接口

1）接口是一个标准、规范，遵守了这个标准，就能干某件事

2）接口可以看成是特殊的抽象类。只能包含常量和抽象方法

3）由interface定义

interface Inter1{ //定义接口
	public static final int NUM = 5;
	public abstract void show();
	
	double PI = 3.141592; //默认public static final
	void sayHi(); //默认public abstract
	
	//int num; //编译错误，程序认为num为常量，但未初始化
	//public void say() {	} //编译错误，不是抽象方法，接口中方法默认都是抽象的
}

3.2、接口的实现

1）接口是需要被实现/继承的，实现类/子类：必须重写接口中的所有抽象方法

2）接口不能被实例化

new Inter1(); //编译错误，不能被实例化
Inter1 o1; //正确，Inter1 类型o1

3）一个类可以通过“implements”关键字“实现”接口，一个类实现了某个接口后必须重写接口中定义的所有方法

interface Inter1{ //定义接口Inter1
	void a();
}

class Coo implements Inter1{ //实现Inter1
	public void a() {	} //重写必须加上public，子类权限必须比父类大
}

4）接口可以作为一种类型声明变量，一个接口类型的变量可以引用实现了该接口的类的对象；通过该变量可以调用该接口中定义的方法

Inter1 o1 = new Coo(); //向上造型
o1.a();

3.3、接口的继承

1）一个类可以实现多个接口，用逗号分隔；若又继承又实现时，应先继承extends后实现implements

interface Inter1{ //定义接口Inter1
	void a();
}

interface Inter2{ //定义接口Inter2
	void b();
}

abstract class Boo{
	abstract void c();
}

class Coo extends Boo implements Inter1,Inter2{ //继承Boo，实现Inter1,Inter2
	public void a() {	} //重写必须加上public，子类权限必须比父类大
	public void b() {	}
	void c() {	} //方法都是默认，权限一致，可以不写public
}

2）接口可以继承接口

public class Task {

	public static void main(String[] args) {
		Inter2 o1 = new Doo(); //向上造型
		Inter1 o2 = new Doo(); //向上造型
	}

}

interface Inter1{ //定义接口Inter1
	void a();
}

interface Inter2 extends Inter1{ //定义接口Inter2并继承Inter1
	void b();
}

class Doo implements Inter2{
	public void a() {	} //重写a，b方法，因为Inter2继承了Inter1
	public void b() {	}
}

3.4、接口的意义

1）同类型用-----继承，不同类型用-----实现

2）类对类-----继承；接口对接口-----继承；类和接口-----实现

3）接口是完全抽象的抽象类

4）接口是继承的单根性的扩展

5）接口不能包含构造方法，抽象类可以包含构造方法

6）接口-----常量；抽象类-----成员变量，常量，普通方法，抽象方法

3.5、设计原则

1）将公共的属性和行为封装到父类中

2）所有子类的行为都一样-----普通方法

3）所有子类的行为不一样-----抽象方法

4）若符合既是也是原则时，使用接口

interface 考勤{
  请假审批()，加班审批()
}
interface 薪资{
void 薪资(){};
}
abstract class 公司员工{
  姓名，年龄，工资
  void 上班打卡(){按指纹、手机打卡}
  void 下班打卡(){按指纹、手机打卡}
  abstract void 完成工作();
}
class 公司人事 extends 公司员工 implements 考勤、薪资{
}
class 公司测试部门经理 extends 公司员工 implements 考勤{
}
class 公司测试工程师 extends 公司员工{
}
class 公司开发工程师 extends 公司员工{
}
class 公司售后 extends 公司员工{
}

四、多态

4.1、什么是多态

1）同一类型的引用指向不同的对象时，有不同的实现-----行为的多态

动物 a1 = new 老虎();
动物 a2 = new 鸟();
动物 a3 = new 鱼();

a1.run(); //地上跑
a2.run(); //天上飞
a3.run(); //水里游

abstract class 动物{
  abstract void run();
}

class 老虎 extends 动物{
  void run(){地上跑}
}

class 鸟 extends 动物{
  void run(){天上飞}
}

class 鱼 extends 动物{
  void run(){水里游}
}

2）同一对象被造型为不同的类型时，有不同的功能-----对象的多态

我 me = new 我();
上班 p1 = me;
孩子他爹 p2 = me;
老公 p3 = me;

p1.挣钱();
p2.揍他();
p3.送孩子上学();
p3.上交工资卡();

interface 上班{
  void 挣钱();
}

interface 孩子他爹{
  void 揍他();
}

interface 老公{
  void 送孩子上学();
  void 上交工资卡();
}

class 我 implements 上班,孩子他爹,老公{
  public void  挣钱(){}
  public void  揍他(){}
  public void  送孩子上学(){}
  public void  上交工资卡(){}
}

4.2、向上造型

1）父类型的引用指向子类的对象

2）能造型成的类型有：父类型、实现的接口

3）能点出来什么，看引用类型

4）向上造型（造型为父类）之后，能点出来的东西（方法）等于或少于子类的，因为子类是继承父类

4.3、强制类型转换

成功的条件有两个：

条件1：引用所指向的对象，就是该类型

条件2：引用所指向的对象，实现了该接口

Aoo o1 = new Boo(); //向上造型
Boo o2 = o1; //编译错误，o1为Aoo类型，Boo为子类型，大类型到小类型需要强转
Boo o2 = (Boo)o1; //正确，符合条件1
Inter1 o3 = (Inter1)o1; //正确，符合条件2；Boo实现了Inter1接口

Coo o4 = (Coo) o1; //ClassCastException类型转换异常

if(o1 instanceof Coo){
  Coo o4 = (Coo) o1;
}

interface Inter1{
}

class Aoo{
}

class Boo extends Aoo implements Inter1{
}

class Coo extends Aoo{
}

注：父类大，子类小；向上造型-----自动类型转换

4.4、instanceof

1）建议强转之前通过instanceof来判断引用是否是某种类型

2）instanceof返回boolean结果，强转成功的条件就是它为true的条件

System.out.println(o1 instanceof Boo); //true
System.out.println(o1 instanceof Inyerl); //true
System.out.println(o1 instanceof Coo); //false

五、内部类

有自己独立的.class文件（位置：…/bin/oo）

5.1、成员内部类：不太常用

1）类中套类，外面的叫外部类，里面的叫内部类

Boo o = new Boo();
class Aoo{ //外部类
	class Boo{ //内部类
		
	}
}

2）内部类通常只服务于外部类，对外不具备可见性

class Test{
	void show() {
		Aoo o = new Aoo();
		Boo o = new Boo(); //编译错误
	}
}

class Aoo{ //外部类
	class Boo{ //内部类-----Aoo的一个成员（不是独立的）
		
	}
}

3）内部类对象通常是在外部类中创建

class Aoo{
	void show() {
		Boo o = new Boo(); //正确
	}
	class Boo{
		
	}
}

4）内部类可以直接访问外部类的成员（包括私有的）；内部类中有个隐式的引用指向创建它的外部类对象

//语法：外部类名.this.外部变量
class Aoo{
	private int a;
	void show() {
		Boo o = new Boo(); //正确
	}
	class Boo{
		void test() {
			System.out.println(a); //正确
			System.out.println(Aoo.this.a); //正确
			System.out.println(this.a); //编译错误，this代表Boo，Boo类没有变量a
		}
	}
}

5.2、匿名内部类：比较常用

1）如果想创建一个类的对象（通常这个类需要实现某个接口或者继承某个类），并且对象只被创建一次，此时该类不必命名，称为匿名内部类

2）匿名内部类中访问外部的数据，该数据必须是final的（jdk版本不一致，有些版本可以不用加）

5.3、内部类的应用

1）当一个类存在的价值仅仅是为某一个类服务时，应当使其成为那个类的内部类

2）内部类一般情况下对外不可见，除了包含它的外部类外，其他类无法访问到它

3）内部类可以很方便的访问其外部类的私有属性

4）匿名内部类应用在接口回调、事件监听等场合

六、面向对象三大特征

6.1、封装

1）类：封装的是对象的属性和行为

2）方法：封装的是具体的逻辑功能实现

3）访问控制修饰符：封装的是访问的权限

6.2、继承

1）作用：避免代码重复，有利于代码的重用

2）父类：所有子类所共有的属性和行为；子类：子类所特有的属性和行为

3）子继承（extends）父后，子具有：父+子（变量和方法）

4）传递性（父传子，子传孙）、单一继承（一个类只能继承一个父类）、多接口实现（一个类可以实现多个接口）

6.3、多态

1）意义：行为的多态、对象的多态

2）向上造型、强制类型转换、instanceof

3）多态的表现形式：重写+重载

4）重写与重载的相同之处：都是多态的表现形式

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小鹿快跑～

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值