从零开始学Java，学习笔记Day10

最新推荐文章于 2025-05-15 20:49:36 发布
最新推荐文章于 2025-05-15 20:49:36 发布
阅读量902 收藏 15
点赞数 18
文章标签： java 学习 笔记 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_51876888/article/details/143863182
版权

Day10

面对对象

一、final

理解：最终的

作用：

  1. 修饰类：该类为最终的类，不能被继承
  2. 修饰方法：该方法为最终的方法，不能被子类重写
  3. 修饰变量：该变量为常量，不能重新赋值
  4. 常量的命名规范：全部字母大写，单词之间使用下划线隔开

经验：

  • 工具类一般使用final修饰
  • final一般和static一起修饰变量 – 静态常量
public class Person {

	private String name;
	private char sex;
	private int age;
	
	public static final String star = "地球";
	
	public Person() {
	}

	public Person(String name, char sex, int age) {
		this.name = name;
		this.sex = sex;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public char getSex() {
		return sex;
	}

	public void setSex(char sex) {
		this.sex = sex;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", sex=" + sex + ", age=" + age + "]";
	}
}

//修饰类：该类为最终的类，不能被继承
//public final class A {
public class A {

	//修饰方法：该方法为最终的方法，不能被子类重写
	//public final void method(){
	public void method(){
		System.out.println("A类的method方法");
	}
}

public class B extends A{

	@Override
	public void method() {
		
		final int MAX = 100;
		System.out.println("B类重写A类的method方法 -- " + MAX);
	}
}

二、抽象类及抽象方法的使用

需求：编写人类及其子类，操作对象

//注意：抽象方法必须在抽象类中
public abstract class Person {

	private String name;
	private char sex;
	private int age;
	
	public Person() {
	}

	public Person(String name, char sex, int age) {
		this.name = name;
		this.sex = sex;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public char getSex() {
		return sex;
	}

	public void setSex(char sex) {
		this.sex = sex;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
	
	//抽象方法：交给非抽象的子类去实现
	//特点：没有代码块(功能没有具体的实现)
	public abstract void eat();
	
	public void sleep(){
		System.out.println(this.name + "睡觉");
	}
}

public abstract class Chinese extends Person{

	private String id;
	
	public Chinese() {
	}

	public Chinese(String name, char sex, int age, String id) {
		super(name, sex, age);
		this.id = id;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}
	
	public abstract void hobbies();

	@Override
	public String toString() {
		return "Chinese [id=" + id + ", toString()=" + super.toString() + "]";
	}
}

public class SiChuan extends Chinese{
	
	public SiChuan() {
	}
	
	public SiChuan(String name, char sex, int age, String id) {
		super(name, sex, age, id);
	}

	@Override
	public void hobbies() {
		System.out.println(super.getName() + "喜欢打麻将、砸金花、斗地主");
	}

	@Override
	public void eat() {
		System.out.println(super.getName() + "吃火锅、串串香");
	}

	@Override
	public String toString() {
		return "SiChuan [toString()=" + super.toString() + "]";
	}
	
}

抽象类及抽象方法的深入

面试题：

  1. 抽象类中只能有抽象方法？

    抽象类中可以有：成员属性、静态属性、构造方法、成员方法、静态方法、抽象方法

  2. 抽象类中不可以没有抽象方法？

    可以，但是毫无意义

  3. 如果父类是抽象类，则子类必须实现父类的抽象方法？

    不一定，因为子类如果是抽象类，可以不用实现父类的抽象方法

  4. 抽象类不能有构造方法？

    可以有

  5. 可以使用new关键字来创建抽象类对象？

    不可以的，抽象类不能创建对象！！！

三、接口的使用

理解：接口是一个特殊的抽象类

  • JDK1.7 - 接口中只能使用静态常量、抽象方法
  • JDK1.8 - 接口中只能使用静态常量、抽象方法、静态方法、默认方法

应用场景：接口一般用于定义规范

需求：定义学生管理系统的规范

public interface StudentManagerSystem {
	
	//注意：接口中的属性默认使用public static final修饰 -- 静态常量
	int NAME = 1;
	int SEX = 2;
	int AGE = 3;
	int CLASS_ID = 4;
	int ID = 5;

	//注意：接口中的抽象方法默认使用public abstract修饰
	//经验：为了代码的可读性，一般会加public
	public void add(String name,char sex,int age,String classId,String id);
	
	public void remove(String classId,String id);
	
	/**
	 * 修改学生信息
	 * @param classId 班级号
	 * @param id 学号
	 * @param type 修改的类型（1-姓名 2-性别 3-年龄 4-班级号 5-学号）
	 * @param val 修改的值
	 */
	public void update(String classId,String id,int type,Object val);
	
	default void printStudent(){
		System.out.println("打印学生的功能");
	}
	
	public static void method(){
		System.out.println("静态方法");
	}
}

//注意：类和接口的关系是多实现
public class StudentManagerSystemImpl implements StudentManagerSystem {

	@Override
	public void add(String name, char sex, int age, String classId, String id) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void remove(String classId, String id) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void update(String classId, String id, int type, Object val) {
		// TODO Auto-generated method stub
		
	}

}

public class Test01 {

	public static void main(String[] args) {
		
		StudentManagerSystemImpl sms = new StudentManagerSystemImpl();
		
		//调用实现类实现的方法
		sms.add("蔡徐坤", '男', 18, "2401", "01");
		
		//调用接口提供的默认方法
		sms.printStudent();
		
		//调用接口提供的静态方法
		StudentManagerSystem.method();
	}
}

接口的深入

关系：

  • 类 - 类：单继承
  • 类 - 接口：多实现
  • 接口 - 接口：多继承

面试题：

  1. 一个类可以实现多个接口？

    可以

  2. 一个接口可以实现多个接口？

    不能

  3. 接口里面的方法不一定都是抽象的？

    JDK1.7 - 接口中只能使用静态常量、抽象方法

    JDK1.8 - 接口中只能使用静态常量、抽象方法、静态方法、默认方法

  4. 接口解决了类的单继承问题？

    是的

  5. 一个类是否可以继承一个类并同时实现多个接口？

    可以

  6. 接口可以new对象？

    不可以，接口不能new对象

四、类的多态

需求：老师骑着自行车上班
步骤：

  1. 创建Car类，编写open()、close()
  2. 改动原有Teacher类，编写start()、stop()

**设计原则：**前人给我们总结的经验，告诉我们什么不要干

**设计模式：**前人给我们总结的经验，告诉我们怎么干

OCP - 开闭原则

  • O - open - 在需求更改时，对于创建类是欢迎的
  •    C - close - 在需求更改时，对于修改原有类是拒绝的

  • 	P - principle - 原则

**需求迭代：**自行车 -> 小汽车 -> 飞机

public abstract class Vehicle {

	public abstract void open();
	public abstract void close();
}

public class Bike extends Vehicle{

	@Override
	public void open(){
		System.out.println("自行车：握好扶手，踩下脚踏板");
	}
	
	@Override
	public void close(){
		System.out.println("自行车：捏刹车");
	}
}

public class Car extends Vehicle{

	@Override
	public void open(){
		System.out.println("小汽车：踩油门");
	}
	
	@Override
	public void close(){
		System.out.println("小汽车：踩刹车，熄火");
	}
}

public class Plane extends Vehicle{

	@Override
	public void open() {
		System.out.println("飞机：飞");
	}

	@Override
	public void close() {
		System.out.println("飞机：降落着陆");
	}

}

public class Teacher {

	public void start(Vehicle v){
		v.open();
	}
	
	public void stop(Vehicle v){
		v.close();
	}
}

public class Test01 {

	public static void main(String[] args) {
		
		Teacher t = new Teacher();
		
		//类的多态：子类对象指向父类引用
		//理解：父类引用中存储的是子类对象在堆内存中的地址
		Vehicle v = new Plane();
		
		t.start(v);
		System.out.println("欣赏风景...");
		t.stop(v);
		
	}
}

五、接口的多态

需求：模拟电脑连接外部设备

public class Computer {

	public void connection(USB usb){
		usb.use();
	}
}

public interface USB {

	public void use();
}

public class Mouse implements USB{

	@Override
	public void use() {
		System.out.println("鼠标：左点点、右点点...");
	}

}

public class Keyboard implements USB{

	@Override
	public void use() {
		System.out.println("键盘：输入数据...");
	}

}

public class Test01 {

	public static void main(String[] args) {
		
		Computer computer = new Computer();
		
		//接口的多态：实现类对象指向接口的引用
		//理解：接口的引用中存储的是实现类对象在堆内存的地址
		USB usb = new Keyboard();
		computer.connection(usb);
	}
}

六、对象转型

分类：

自动转型/向上转型：子类类型 转 父类类型

注意：

  1. 向上转型就是多态！！！
  2. 可以调用父类的非私有化成员属性
  3. 可以调用父类的非私有化成员方法
  4. 不可以调用子类的独有的成员属性和方法
  5. 可以调用子类重写父类的方法

多态的优缺点：

  • 优点：需求迭代时不违反OCP原则
  • 缺点：不可以调用子类的独有的成员属性和方法

强制转型/向下转型：父类类型 转 子类类型

public class Animal {

}

public class Cat extends Animal{

	public void shout(){
		System.out.println("ΠʽΓ¨ίχίχίχ~~~");
	}
}


public class Dog extends Animal{

	public void eat(){
		System.out.println("小狗吃骨头");
	}
}

public class Test01 {

	public static void main(String[] args) {
		
		//错误写法：父类对象不能转子类类型
		//ClassCastException - 类型转换异常
		//经验：出现该异常，一定要看报错信息
		//Dog dog = (Dog) new Animal();
		
		//注意：所谓向下转型，一定是先向上转型后，再向下转型
		
		Animal an = new Dog();
		
		//经验：向下转型，最好使用instanceof判断，不然容易出现ClassCastException
		if(an instanceof Dog){//判断引用an中所指的对象是否属于Dog类
			Dog dog = (Dog) an;
			dog.eat();
		}else if(an instanceof Cat){//判断引用an中所指的对象是否属于Cat类
			Cat cat = (Cat) an;
			cat.shout();
		}
	}
}

向下转型

public class Test01 {

	public static void main(String[] args) {
		
		String str1 = new String("abc");
		System.out.println(str1.equals(new Object()));//false
		
		System.out.println("---------------------------------");
		
		MyString my1 = new MyString("abc");
		System.out.println(my1.equals(new Object()));//true
	}
}

public class MyString {

	private final char[] value;
	
	public MyString(String original) {
		//toCharArray() -- 将字符串转换为字符数组
		value = original.toCharArray();
	}
	
	@Override
	public boolean equals(Object obj) {
		
		if(this == obj){
			return true;
		}
		
		if(obj instanceof MyString){
			MyString my = (MyString) obj;
			char[] v1 = this.value;//my1.value -- ['a','b','c']
			char[] v2 = my.value;//my2.value   -- ['a','b','c']
			
			int length = v1.length;
			if(length == v2.length){
				for (int i = 0; i < length; i++) {
					if(v1[i] != v2[i]){
						return false;
					}
				}
				return true;
			}
		}
		return false;
	}
	
	@Override
	public String toString() {
		String str = "";
		for (char element : value) {
			str += element;
		}
		
		return str;
	}
}

总结：

  1. final

    ​ 修饰类

    ​ 修饰方法

    ​ 修饰变量

  2. 抽象类及抽象方法（使用、深入）

  3. 接口（使用、深入）

  4. 多态

    ​ 类的多态：子类对象指向父类引用

    ​ 接口的多态：实现类的对象指向接口的引用

  5. 对象转型

    ​ 向上转型（注意：多态的优缺点）

    ​ 向下转型（注意：使用instanceof判断）

java基础学习笔记（期末复习）
qq_46170751的博客
03-13 1549
定义：是Java语言中已经被赋予特定意义的一些单词。关键字中所有字母都为小写。标识符是用来标识类名、变量名、方法名、数组名、文件名的有效字符序列。函数就是在类中定义，功能独立的一段程序，函数也称为方法。
韩顺平零基础Java(超详细笔记梳理) 01——helloworld初编写、编程习惯养成、基本符号认识和DOS命令
apple_68589597的博客
07-04 1081
本篇文章是对韩顺平老师课程P16-P32重点内容的总结，包括：快速编写一个hello world 程序；编程学习的核心方法、良好习惯养成；转义字符、注释的介绍；DOS命令的简单介绍。
从零开始学Java，学习笔记Day24
qq_51876888的博客
12-19 1459
1.字节流 BufferedOutputStream、BufferedInputStream 2.字符流 OutputStreamWriter、InputStreamReader FileWriter、FileReader BufferedWriter、BufferedReader 3.对象流 ObjectOutputStream、ObjectInputStream 理解：序列化、反序列化、Serializable接口、transient
从零开始学Java，学习笔记Day01
qq_51876888的博客
11-07 703
初识Java，环境搭建，发展史，编写第一个Java程序
从零开始学Java，学习笔记Day16
qq_51876888的博客
11-26 911
泛型 。LinkedList、HashSet、LinkedHashSet、TreeSet，常用方法以及特点（重点）。Vector 、stack(了解)
从零开始学Java，学习笔记Day06
qq_51876888的博客
11-14 816
方法版本的万年历，一维数组的使用，数组的排序 – 了解数组的查找 – 了解数组的复制、扩容、删除 – 重要！！！数组作为方法的参数和返回值，可变参数，Arrays。
从零开始学Java，学习笔记Day04
qq_51876888的博客
11-13 764
switch的使用switch的深入 – 重要for循环 – 重要for循环嵌套 – 重要！！！while循环do-while循环特殊的流程控制语句重点放在break、continue。
从零开始学Java，学习笔记Day03
qq_51876888的博客
11-08 715
1. Scanner类 2. 运算符 字符串拼接符 三目运算符 位运算 运算符的优先级别 3. Java执行语句 4. if分支
从零开始学Java，学习笔记Day09
qq_51876888的博客
11-18 736
继承的使用，继承的深入，super，重写，访问修饰符 – 做实验Object（了解、使用、MyString）
从零开始学Java，学习笔记Day07
qq_51876888的博客
11-15 789
eclipse，二维数组， – 理解五子棋 ---- 重要，初识面向对象 – 重要！！！！！
从零开始学Java，学习笔记Day12
qq_51876888的博客
11-19 391
包装类 – 注意：Integer底层，String的使用，StringBuffer和StringBuilder的使用，深入String，深入StringBuffer和StringBuilder。
Java学习笔记：从零到三大框架全解析
"这是一份详尽的Java学习笔记大全，旨在帮助读者从零基础开始掌握Java开发，深入理解并学习Java开发的三大框架。这份长达六个月的学习成果包含了多个方面的内容，从基础的Linux环境设置开始，如命令行操作（如`pwd`,...
零基础大数据学习笔记.zip
01-03
本学习笔记从Day01开始，逐步引导学习者建立学习路线并掌握Linux操作系统基础，因为Linux是大数据领域中服务器操作系统的主要选择。接下来的学习内容包括了Hadoop的学习，Hadoop是一个由Apache基金会开发的分布式...
Java 多线程应用循环输出ABC
26857259
05-14 193
Java 多线程应用循环输出ABC
HashSet
最新发布
weixin_51718998的博客
05-15 581
（1）HashSet的去重机制：hashCode()+equals()，底层先通过存入对象，进行运算得到一个hash值，通过hash值得到对应的索引，如果发现table索引所在的位置，没有数据，就直接存放，如果有数据，就进行equals[遍历]比较，如果比较后，不相同就加入，否则就不加入。在开发中，选择什么集合实现类，主要取决于业务操作特点，然后根据集合实现类特性进行选择，分析如下：1）先判断存储的类型（一组对象[单列]或一组键值对[双列]）map.put("no1","hahaha");
SQLServer如何为数据库创建只读账号，并测试是否只读成功。直接代入替换就行，全流程，新手替换复制即可。
weixin_44858074的博客
05-14 192
本文详细介绍了如何在 SQL Server 中为数据库 SQL_Xxxx 创建一个名为 zhidu_os 的只读账号，并将其密码设置为 SQL_Passwd
private String tempUrl = “./Temp“； 再linux和windows下是否都有效
日常笔记 | 干货分享 | 毕设源码 | 毕设指导 | 答辩指导
05-14 191
private String tempUrl = "./Temp"; 再linux和windows下是否都有效
SpringBoot自动装配的原理
qq_63981644的博客
05-14 237
SpringBoot自动装配的原理。
springboot3+vue3融合项目实战-大事件文章管理系统-新增文章分类
qq_44721704的博客
05-13 387
然后建立service接口和serviceimpl实现类。新建categorycontroller类。然后新增mapper接口。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值