Java学习第四章(二)

已于 2022-04-12 15:36:51 修改
阅读量65 收藏
点赞数
分类专栏： JAVA学习(进阶班) 文章标签： java 学习 开发语言
于 2022-02-28 22:17:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49883619/article/details/123172344
版权

视频链接：https://www.bilibili.com/video/BV1Rx411876f?p=1

视频范围P526 - P542

目录描述

源码及API文档

1.概述

从哪可以看object类当中的常用方法？

  • 第一种：去源代码中找（比较麻烦，源代码也比较难）
  • 第二种：去查阅java的类库的帮助文档

API：

  • API是应用程序编程接口（Application Program Interface）
  • 整个JDK的类库就是一个javase的API
  • 每一个API都会配置一套API帮助文档
  • SUN公司提前写好的这套类库就是API（一般每一份API都对应一份API帮助文档）

目前为止只需要知道以下几个方法就行：

  1. protected Object clone() //负责对象克隆的
  2. int hashCode() //获取对象哈希值的一个方法
  3. boolean equals(Object obj) //判断两个对象是否相等
  4. String toString() //将对象转换成字符串形式
  5. protected void finalize() //垃圾回收器负责调用的方法

2.Object的toString方法

  1. 源码：
public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
  1. 源代码上toString()方法的默认实现是：类名@对象的内存地址转换为十六进制的形式
  2. toString()方法设计目的：通过调用这个方法可以将一个“java对象”转换成“字符串表示形式”
  3. SUN公司开发java语言的时候，建议所有的子类都去重写toString()方法
    toString()方法应该是一个简洁的、详实的、易阅读的

代码示例：

时间类：

package toString;

public class MyTime {
	
	int year;
	int month;
	int day;
	
	public MyTime() {
		
	}
	
	public MyTime(int year, int month, int day) {
		this.year = year;
		this.month = month;
		this.day = day;
	}
	
	//重写toString()方法
	public String toString() {
		
		return this.year + "年" + this.month + "月" + this.day + "日";
	}	
}

测试类：

package toString;

public class Test01 {

	public static void main(String[] args) {
		
		MyTime t1 = new MyTime(1997,7,27);
		
		//一个日期对象转换成字符串形式的话，更希望看到具体的日期信息
		String s1 = t1.toString();
		
		//MyTime类重写toString()方法之前
		//System.out.println(s1);//输出为：toString.MyTime@1175e2db
		
		//MyTime类重写toString()之后
		System.out.println(s1);//输出为：1997年7月27日
		
		//等价于
		System.out.println(t1.toString());//输出为：1997年7月27日
		
		//注意：输出引用的时候，会自动调用该引用的toString()方法
		System.out.println(t1);//输出为：1997年7月27日
	}
}

3.Object的equals方法

3.1 基本概念

  1. 源码（Object类的默认实现）：
    public boolean equals(Object obj) {
        return (this == obj);
    }
  1. SUN公司设计目的：通过equals方法来判断两个对象是否相等
    代码示例：

时间类：

package toString;

public class MyTime {
	
	int year;
	int month;
	int day;
	
	public MyTime() {
		
	}
	
	public MyTime(int year, int month, int day) {
		this.year = year;
		this.month = month;
		this.day = day;
	}
	
	//默认的equals方法
	//public boolean equals(Object obj) {
    //    return (this == obj);
    //}
	
	//重写的equals方法
	public boolean equals(Object obj) {
		//当年相同，月相同，并且日也相同的时候，表示两个日期相同，两个对象相等
		//获取第一个日期的年月日
		int year1 = this.year;
		int month1 = this.month;
		int day1 = this.day;
		
		//获取第二个日期的年月日
		if (obj instanceof MyTime) {
			
			MyTime t = (MyTime) obj;
			
			int year2 = t.year;
			int month2 = t.month;
			int day2 = t.day;
			
			if (year1 == year2 && month1 == month2 && day1 == day2) {
				return true;
			}
		}
		//程序能够指向到此表示日期不相等
		return false;
    }	
}

测试类：

package toString;

public class Test02 {

	public static void main(String[] args) {
		
		MyTime t1 = new MyTime(1997,7,27);
		MyTime t2 = new MyTime(1997,7,27);
		
		//测试一下，两个对象是否相等
		//这里的“==”判断的是：t1中保存的对象内存地址和t2中保存的对象内存地址是否相等
		System.out.println(t1 == t2);//输出为：false
		
		//重写的equals方法之前(比较的是对象内存地址)
		//boolean flag = t1.equals(t2);
		//System.out.println(flag);//输出为：false
		
		//重写的equals方法之后(比较的是内容)
		boolean flag1 = t1.equals(t2);
		System.out.println(flag1);//输出为：true
	}
}

但是当遇到下面情况的时候：

package toString;

public class Test02 {

	public static void main(String[] args) {
		
		MyTime t1 = new MyTime(1997,7,27);
		MyTime t4 = null;
		System.out.println(t1.equals(t4));//输出为：false
	}
}

也可以运行，但是效率太低了，于是对时间类进行改良：

时间类：

package toString;

public class MyTime {
	
	int year;
	int month;
	int day;
	
	public MyTime() {
		
	}
	
	public MyTime(int year, int month, int day) {
		this.year = year;
		this.month = month;
		this.day = day;
	}
	
	//改良的equals方法
	public boolean equals(Object obj) {
		
		//如果obj是空，直接返回false
		if (obj == null) {
			return false;
		}
		
		//如果obj不是一个MyTime,没必要比较了，直接返回false
		if (!(obj instanceof MyTime)) {
			return false;
		}
		
		//如果this和obj保存的内存地址相同，没必要比较了，直接返回true
		if (this == obj) {
			return true;
		}
		
		MyTime t = (MyTime)obj;
		if (this.year == t.year && this.month == t.month && this.day == t.day) {
			return true;
		}
		
		//程序能到这里返回false
		return false;
    }
}

进一步改良：

package toString;

public class MyTime {
	
	int year;
	int month;
	int day;
	
	public MyTime() {
		
	}
	
	public MyTime(int year, int month, int day) {
		this.year = year;
		this.month = month;
		this.day = day;
	}
	
	//进一步改良的equals方法
	public boolean equals(Object obj) {
		
		//如果obj是空，或者obj不是一个MyTime 直接返回false
		if (obj == null || !(obj instanceof MyTime)) {
			return false;
		}
		
		//如果this和obj保存的内存地址相同，没必要比较了，直接返回true
		if (this == obj) {
			return true;
		}
		
		MyTime t = (MyTime)obj;
		return this.year == t.year && this.month == t.month && this.day == t.day;
    }
}

3.2 String类重写toString和equals

  1. String类已经重写了toString方法
  2. String类已经重写了equals方法，比较两个字符串不能使用==，必须使用equals，equals是通用的
  3. java中基本数据类型比较是否相等，使用==
  4. java中所有的引用数据类型统一使用equals方法来判断是否相等
package toString;

public class Test03 {

	public static void main(String[] args) {
		
		//大部分情况下，采用这样的方式创建字符串对象
		String s1 = "hello";
		String s2 = "abc";
		
		//实际上String也是一个类，不属于基本数据类型，存在构造方法
		String s3 = new String("Test1");
		String s4 = new String("Test1");
		
		//==判断的是内存地址，不是内容
		System.out.println(s3 == s4);//输出为：false
		
		//比较两个字符串必须调用equals方法
		//String类已经重写了equals方法
		System.out.println(s3.equals(s4));//输出为：true
		
		//String类已经重写了toString方法
		String x = new String("西南大学");
		//如果没有重写那么输出结果为：java.lang.String@十六进制的地址
		System.out.println(x.toString());//输出为：西南大学
		System.out.println(x);//输出为：西南大学
	}
}

3.3 重写Object的equals方法

学生类：

package toString;

public class Student {
	
	int no;
	String school;
	
	public Student() {

	}

	public Student(int no, String school) {
		this.no = no;
		this.school = school;
	}
	
	//重写toString方法
	public String toString() {
		return "学号" + no + ",所在学校名称" + school;
	}
	
	//重新equals方法
	//需求：当一个学生的学号相等，并且学校相同时，表示同一个学生
	public boolean equals(Object obj) {
		
		if (obj == null || !(obj instanceof Student)) {
			return false;
		}
		if (this == obj) {
			return true;
		}
		
		Student s = (Student)obj;
		
		return this.no == s.no && this.school.equals(s.school);
		
		//字符串用双等号比较可以吗？
		//不可以
		//return this.no == s.no && this.school == s.school;
	}	
}

测试类：

package toString;

public class Test04 {

	public static void main(String[] args) {
		
		Student s1 = new Student(5108,"西南大学");
		Student s2 = new Student(5108,"西南大学");
		
		System.out.println(s1 == s2);//输出为：false
		System.out.println(s1.equals(s2));//输出为：true
		
		//下面情况为特殊情况,用student的类中最后注释掉的方法返回就会出现问题
		//Student s3 = new Student(5108,new String("西南大学"));
		//Student s4 = new Student(5108,new String("西南大学"));
		
		//System.out.println(s1 == s2);//输出为：false
		//System.out.println(s1.equals(s2));//输出为：false
	}
}

3.4 equals方法深层次理解

注意：equals方法重写的要彻底

地址类：

package toString;

public class Address {
	
	String city;
	String street;
	String zipcode;
	
	public Address() {

	}

	public Address(String city, String street, String zipcode) {
		this.city = city;
		this.street = street;
		this.zipcode = zipcode;
	}
	
	//注意：这里并没有重写equals方法
	//这里的equals方法判断的是：Address对象和Address对象是否相等	
}

用户类：

package toString;

public class User {
	
	//用户名
	String name;
	//用户地址
	Address addr;
	
	public User() {

	}

	public User(String name, Address addr) {
		this.name = name;
		this.addr = addr;
	}
	
	//对equals方法重写
	//重写规则：当一个用户的用户名和家庭住址都相同，表示同一个用户
	//这个equals判断的是User对象和User对象是否相等
	public boolean equals(Object obj) {
		
		if (obj == null || !(obj instanceof User)) {
			return false;
		}
		if (this == obj) {
			return true;
		}
		
		User u = (User)obj;
		
		return this.name.equals(u.name) && this.addr.equals(u.addr);
	}
}

测试类：

package toString;

public class Test05 {

	public static void main(String[] args) {
		
		User u1 = new User("liujie",new Address("重庆","北碚区","5108"));
		User u2 = new User("liujie",new Address("重庆","北碚区","5108"));
		
		System.out.println(u1.equals(u2));//输出为：false
	}
}

针对上面的问题，需要在地址类中也要定义equals方法：

地址类：

package toString;

public class Address {

	String city;
	String street;
	String zipcode;

	public Address() {

	}

	public Address(String city, String street, String zipcode) {
		this.city = city;
		this.street = street;
		this.zipcode = zipcode;
	}

	// 注意：这里并没有重写equals方法
	// 这里的equals方法判断的是：Address对象和Address对象是否相等
	public boolean equals(Object obj) {

		if (obj == null || !(obj instanceof Address)) {
			return false;
		}
		if (this == obj) {
			return true;
		}

		Address a = (Address) obj;

		return this.city.equals(a.city) && this.street.equals(a.street) && this.zipcode.equals(a.zipcode);
	}
}

测试类：

package toString;

public class Test05 {

	public static void main(String[] args) {
		
		User u1 = new User("liujie",new Address("重庆","北碚区","5108"));
		User u2 = new User("liujie",new Address("重庆","北碚区","5108"));
		
		System.out.println(u1.equals(u2));//输出为：true
	}
}

4.Object的finalize方法

  1. 源码：
protected void finalize() throws Throwable{}
  1. finalize()方法只有一个方法体，里面没有代码，而且这个方法是protected修饰的
  2. 这个方法不需要程序员手动调用，JVM的垃圾回收器负责调用这个方法
    如：不像equals、toString，这两个需要写代码调用，但是finalize()方法只需要重写，重写完将来自动会有程序来调用
  3. finalize()方法的执行时机：
    当一个java对象即将被垃圾回收器回收的时候，垃圾回收器负责调用finalize()方法
  4. finalize()方法实际上是SUN公司为java程序员准备的一个时机，垃圾销毁时机。
    如果希望在对象销毁时机执行一段代码的话，这段代码要写到finalize()方法当中
  5. 静态代码块的作用是什么？
    静态代码块在类加载时刻执行，并且只执行一次，这是一个SUN准备的类加载时机
static{
 .....
}
  1. finalize()方法同样也是SUN为程序员准备的一个时机，这个时机是垃圾回收时机
  2. java中的垃圾回收器不是轻易启动的，垃圾太少，或者时间没到，种种条件下，有可能启动，也有可能不启动

人类：

package toString;

public class Person {
	
	//重写finalize()方法
	//Person类型的对象被垃圾回收器回收的时候，垃圾回收器负责调用：p.finalize();
	protected void finalize() throws Throwable{
		System.out.println("即将被销毁！！！");
	}
}

测试类：

package toString;

import java.util.Iterator;

public class Test06 {

	public static void main(String[] args) {

		// 创建对象
		// Person p = new Person();

		// 怎么将Person对象变成垃圾

		// 第一种方法
		// for (int i = 0; i < 100000000; i++) {
		// Person p = new Person();
		// p = null;
		// }

		// 第二种
		for (int i = 0; i < 100000000; i++) {
			Person p = new Person();
			p = null;
			
			//有一段代码可以建议垃圾回收器启动
			if (i % 2 == 0) {
				System.gc();//建议启动垃圾回收器，但只是建议，可能不启动，也可能启动
			}
		}
	}
}

运行效果：

在这里插入图片描述

5.Object的hashCode方法

  1. 源码
    这个方法不是抽象方法，带有native关键字，底层调用C++程序
public native int hashCode();
  1. hashCode()方法返回的是哈希码：实际上就是一个java对象的内存地址，经过哈希算法，得出的一个值
  2. hashCode()方法的执行结果可以等同看做一个java对象的内存地址
package toString;

public class Test07 {

	public static void main(String[] args) {
		
		Object o = new Object();
		int hashCodeValue = o.hashCode();
		
		//对象内存地址经过哈希算法转换的一个数字，可以等同看做内存地址
		System.out.println(hashCodeValue);//输出为：2111991224
		
		MyClass mc = new MyClass();
		int hashCodeValue2 = mc.hashCode();
		
		System.out.println(hashCodeValue2);//输出为：917142466
		//等价于
		System.out.println(mc.hashCode());//输出为：917142466
		
	}

}

class MyClass{
	
}

6.内部类

6.1 内部类概述

  1. 内部类：在类的内部又定义了一个新的类
  2. 内部类分类
内部类备注
静态内部类类似于静态变量
实例内部类类似于实例变量
局部内部类类似于局部变量
  1. 使用内部类编写的代码可读性很差，能不用尽量不用
class Test01 {
	// 静态变量
	static String country;

	// 该类在类的内部，被称为内部类
	// 由于前面的static，所以称为“静态内部类”
	static class Inner1 {
	}

	// 实例变量
	int age;

	// 没用static叫做“实例内部类”
	class Inner2 {
	}

	// 方法
	public void doSome() {
		// 局部变量
		int i = 100;
		// “局部内部类”
		class Inner3 {
		}
	}

	public void doOther() {
		// doSome()方法中的局部内部类Inner3，在doOther()中不能用
	}
}

6.2 匿名内部类

  1. 匿名内部类：类没有名字
  2. 匿名内部类是局部内部类中的一种
  3. 学习匿名内部类主要是让大家以后在阅读别人代码的时候能理解

示例代码：

当不使用匿名内部类的时候：

package toString;

public class Test08 {

	public static void main(String[] args) {
		MyMath mm = new MyMath();
		mm.mySum(new ComputeImpl(), 100, 200);
	}

}

//负责计算的接口
interface Compute{
	
	//抽象方法
	int sum(int a,int b);
}

//Compute接口的实现类
class ComputeImpl implements Compute{
	
	//对方法的实现
	public int sum(int a, int b) {
		return a + b;
	}
}

//数学类
class MyMath{
	
	//数学求和
	public void mySum(Compute c, int x, int y) {
		int retValue = c.sum(x, y);
		System.out.println(x + "+" + y + "=" + retValue);
	}
}

当使用匿名内部类的时候，不需要对接口进行实现：

package toString;

public class Test08 {

	public static void main(String[] args) {
		MyMath mm = new MyMath();
		//使用匿名内部类
		//表面看上去好像是接口可以直接new，实际上并不是接口可以new，后面的{}代表了对接口的实现
		mm.mySum(new Compute(){
		public int sum(int a, int b) {
		return a + b;
	   }
	}, 100, 200);
	}

}

//负责计算的接口
interface Compute{
	
	//抽象方法
	int sum(int a,int b);
}

//数学类
class MyMath{
	
	//数学求和
	public void mySum(Compute c, int x, int y) {
		int retValue = c.sum(x, y);
		System.out.println(x + "+" + y + "=" + retValue);
	}
}

总结：
不建议使用匿名内部类，因为一个类没有名字，没有办法重复使用，另外代码太乱，可读性太差

计算机量子狗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java基础学习第四章
04-09
循环结构 循环语句顾名思义就是当满足循环条件的情况下，反复执行某一段代码，这段被 重复执行的代码被称为循环体语句，当反复把循环判断执行这个循环体时，需要 在合适的时条件修改为 false，从而结束循环，否则...
Java程序设计与数据结构第四章习题答案
11-05
为学习Java程序设计的基础同学提供习题代码的参考，便于他们掌握多种方法，得到解决问题的思路与想法，Java程序设计与数据结构第四章习题答案！！！
JavaSE 进阶 - 第18章 面向对象（Object和匿名内部类）
佬涛的博客
07-22 311
JavaSE 进阶 - 第18章 面向对象（Object和匿名内部类）一、Object1、JDK类库的根类：Object2、Object类当中有哪些常用的方法？3、toString()方法4、equals()方法5、finalize()方法（了解）6、hashCode方法二、匿名内部类传送门 一、Object 1、JDK类库的根类：Object    这个老祖宗类中的方法我们需要先研究一下，因为这些方法都是所有子类通用的。    任何一个类默认继承Object。就算没有直接继承，最终也会间接继承。 2、Ob
匿名内部类 学习 to Fin
ProveYourself的博客
08-09 178
简单地说：匿名内部类就是没有名字的内部类。什么情况下需要使用匿名内部类？如果满足下面的一些条件，使用匿名内部类是比较合适的：  ·只用到类的一个实例。  ·类在定义后马上用到。  ·类非常小（SUN推荐是在4行代码以下）  ·给类命名并不会导致你的代码更容易被理解。  在使用匿名内部类时，要记住以下几个原则：  ·匿名内部类不能有构造方法。  ·匿名内部类不能定义任何静态成员、方法和
TIOBE 2020年5月编程语言排行榜（TIOBE Index for May 2020）
佬涛的博客
05-08 952
017-Object和匿名内部类（老杜）
dangerous156的博客
07-17 223
目录 Test01.java Test02.java Test03.java Test04.java Test05.java Test06.java Test07.java 匿名内部类 Test01.java Test01.java /* 关于Object类中的toString()方法 1、源代码长什么样？ public String toString() { return this.getClass()...
JavaSE 基础 - 第6章 控制语句
佬涛的博客
07-13 464
JavaSE 基础 - 第6章 控制语句1、控制语句-概述2、选择语句/分支语句 if3、选择语句/分支语句 switch4、循环语句 for 、while、 do..while..5、转向语句 break、 continue、 return传送门 1、控制语句-概述 1.1、控制语句的作用   　控制语句的出现可以让我们的程序具有逻辑性/条理性，可以使用控制语句来实现一个“业务”了。 1.2、控制语句包括几类？   　3类：   　  　选择语句   　  　循环语句   　  　转向语句 1.3、选择语
Java学习路线总结，搬砖工逆袭Java架构师
热门推荐
学Java，找哪吒
09-07 24万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
Java OOP 第五章 指导学习
云哥的博客
03-31 1万+
Java OOP 5 特种部队 文章目录Java OOP 5 特种部队一、内容回顾二、难点突破三、知识梳理——类和对象四、知识梳理——继承五、知识梳理——多态六、知识梳理——抽象类七、知识梳理——接口八、综合练习九、阶段1：设计类结构并完成编码十、阶段2：实现游戏初始化十一、阶段3：实现双方对战十二、冰箱功能显示十三、本章总结 一、内容回顾 类和对象 封装 继承 多态 抽象类和抽象方法 接口 面向对象设计原则 二、难点突破 面向对象编程特性 封装、继承、多态 抽象类和抽象方法 接口
JAVA数据库第四章上机3_Java第二至第四章上机练习题
weixin_29660659的博客
02-27 615
Java第二章~第四章上机题以下页码见第8版教材1、完成P53页2.14题2、完成P53页2.15题，请使用循环编程。输入分别为半年，一年。3、同上题描述进行编程，问要存多少个月，获得的利息大于本金。(此题也可以参考P105页4.8.2 问题:预测未来学费的例子程序清单4-9 FutureTui tion. java)4、参照P38页程序清单2-10 ComputeChange. j ava编写程...
java学习 第一章练习题
yikuaidabin的博客
10-18 5513
java练习题
JAVA学习 第四章作业
rglkt的博客
05-14 3547
编写Java GUI程序，实现一个简单计算器。要求如下： package Ex4; import javax.swing.*; import java.awt.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.util.regex.Matcher; import java.util.regex.Pattern; public class Ex4 { public .
java学习课件第二章
12-21
这是第2章内容 这是关于学习java基础的课件 ...第四章、applet及其应用 第五章、图形用户界面设计 第六章、异常处理 第七章、线程 第八章、集合操作 第九章、文件输入输出 第十章、网络编程
Java课件学习java2使用教程第六章
12-25
java教程资源学习，来源于Java2使用教程第四版第六章接口与实现，以ppt形式讲解如何学习java教程资源学习，来源于Java2使用教程第四版第六章接口与实现，以ppt形式讲解如何学习java教程资源学习，来源于Java2使用...
java学习课件 第四章
12-21
这是关于学习java基础的课件 第一章、java语言基础 ...第四章、applet及其应用 第五章、图形用户界面设计 第六章、异常处理 第七章、线程 第八章、集合操作 第九章、文件输入输出 第十章、网络编程
java环境部署
JiuMeilove的博客
06-04 406
如果你电脑已经下载了 jdk ，那你可以跳过这一步了我这里下载的是java21 你们可以选择自己需要下载的游览进去的页面是这样子的（相比以前这个页面发生很大变化了），可以看见目前 jdk 已经发行到 17 了，jdk 它又分了三个个操作系统，一个是 Linux、一个是 macOS、以及 windows，如果你是在 windows 操作系统上，那当然就下载 windows 对应的 jdk，其次的话就是还会区分你操作系统的处理器是 32 位的还是 64 位的，可以点击 我的电脑 - 属性 查看。
java中Overload和Override的区别
codedadi的博客
06-04 592
当调用Dog对象的makeSound方法时，将执行Dog类中的方法，而不是Animal类中的方法。定义：在子类中，有一个与父类同名、同参数列表、同返回类型（或协变返回类型）的方法，则称子类中的该方法为父类同名方法的重写。子类方法的访问权限不能低于父类方法的访问权限（如父类方法为public，则子类方法也必须是public）。Override（重写）：子类与父类之间，方法名、参数列表和返回类型（或协变返回类型）相同。定义：在同一个类中，方法名相同但参数列表（参数类型、参数数量或参数顺序）不同的多个方法。
JavaScript第九讲：BOM编程
最新发布
星途码客的博客
06-04 1439
今天星途给大家带来JavaScript倒数第二部分知识：BOM编程，希望对码客们有帮助。
Spring异步任务@Async的默认线程池执行器是如何初始化的
简放视野的专栏
06-03 647
Spring异步任务@Async的默认线程池执行器，是从哪里来？是如何初始化的？ 【结论】异步任务@Async的默认线程池执行器是通过TaskExecutionAutoConfiguration#applicationTaskExecutor自动注入的。
头哥java第四章类与对象二
10-20
第四章类与对象二主要介绍了Java中类的继承、多态和抽象类等概念。具体内容包括： 1. 继承：子类可以继承父类的属性和方法，从而实现代码的复用。Java中使用关键字extends来实现继承。 2. 多态：同一种类型的对象，在不同的情况下会表现出不同的行为。Java中通过方法的重载和重写来实现多态。 3. 抽象类：抽象类是不能被实例化的类，它只能被用作其他类的父类。抽象类中可以包含抽象方法，抽象方法没有具体的实现，需要在子类中实现。 4. 接口：接口是一种特殊的抽象类，它只包含常量和抽象方法。接口中的方法都是公共的，不能包含实例变量和构造方法。Java中使用关键字implements来实现接口。 在学习这些概念时，需要注意以下几点： 1. 子类继承父类时，可以使用super关键字调用父类的构造方法和方法。 2. 多态性可以提高代码的灵活性和可扩展性，但也需要注意避免过度使用。 3. 抽象类和接口都是用来实现代码的抽象和封装，需要根据具体的需求来选择使用哪种方式。 4. 在使用接口时，需要注意接口的实现类必须实现接口中的所有方法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值