7.21学习总结

今日学习总结
一、今天做了什么
一、学习 Java
面向对象相关内容，依次复习并学习封装、继承、方法重写、多态、抽象类、接口、匿名内部类，完整完成 Java 面向对象板块全部知识点学习，梳理整套知识框。
1封装
1.1成员变量直接对外暴露，外界可以随意赋值，无法限制非法数据
()class Person{ String name; int age; } public class Test{ public static void main(String[] args) { Person p = new Person(); p.age = -30; // 年龄负数，逻辑错误，代码不会报错 } }
封装思想：隐藏内部数据，对外提供安全访问方式
1.2封装实现步骤
使用 private 修饰成员变量（私有，本类外不能直接访问）
提供 public 的 get/set 方法
setXxx：给变量赋值，可以增加数据校验
getXxx：获取变量值
标准代码示例
class Person{ // 私有成员变量 private String name; private int age; // 构造方法 public Person(){} public Person(String name,int age){ this.name = name; this.age = age; }
// set方法：设置姓名 public void setName(String name){ this.name = name; }
// get方法：获取姓名 public String getName(){ return name; }
// set方法：设置年龄，增加判断 public void setAge(int age){ if(age > 0 && age <=120){ this.age = age; }else{ System.out.println("年龄不合法！"); } }
// get方法：获取年龄 public int getAge(){ return age; }
// 成员方法 public void show(){ System.out.println(name + "," + age); } }
public class Demo { public static void main(String[] args) { Person p = new Person(); // p.age = 20; 报错！private不能直接访问 p.setName("张三"); p.setAge(25); System.out.println(p.getName()); System.out.println(p.getAge()); p.setAge(-5); // 触发非法提示 } }
1.3规则牢记
boolean 类型变量比较特殊：
变量 private boolean isStudent;
获取方法命名：isStudent() 而不是 getStudent ()
private 权限范围：只能当前类内部访问
this 依然作用：区分局部变量和成员变量
2.继承
2.1多个类存在重复代码，可以抽取公共内容放到父类，子类继承父类，复用代码。
格式：
class 子类 extends 父类{ }
父类（超类）：存放共性内容
子类（派生类）：拥有父类所有非私有成员，拓展自己独有的功能
2.2基础示例
// 父类 class Person{ private String name; private int age; // get set public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public void sleep(){ System.out.println("人需要睡觉"); } } // 子类 Student 继承 Person class Student extends Person{ // 子类独有属性 private String id; public String getId() { return id; } public void setId(String id) { this.id = id; } // 子类独有方法 public void study(){ System.out.println("学生学习"); } } public class Test{ public static void main(String[] args) { Student s = new Student(); // 继承来自父类的方法 s.setName("小明"); s.setAge(18); s.sleep(); // 自己的方法 s.setId("2026001"); s.study(); System.out.println(s.getName() + " " + s.getAge() + " " + s.getId()); } }
2.3继承核心规则
Java 单继承：一个子类只能直接继承一个父类
class A extends B,C{}不允许
父类 private 成员不能直接访问，只能通过 get/set 使用
构造方法不能被继承
所有类顶层父类默认：Object
2.4super 关键字
super：代表父类对象引用
用法：
super.成员变量：访问父类成员
super.方法()：调用父类方法
super()：调用父类构造方法，必须放在构造方法第一行
class Person{ private String name; public Person(String name){ this.name = name; } } class Student extends Person{ private String id; // 子类构造 public Student(String name,String id){ super(name); // 调用父类有参构造 this.id = id; } }
2.5方法重写 override
子类出现和父类方法名、参数列表完全一致的方法，就是重写。
作用：子类改写父类原有逻辑
class Person{ public void show(){ System.out.println("人的信息"); } } class Student extends Person{ // 方法重写 @Override // 注解，校验是否为重写 public void show(){ System.out.println("学生的信息"); } }
重写要求：子类访问权限不能低于父类（父 public，子类不能改成 private）
3多态
3.1同一个行为，不同对象有不同实现形态。
前提条件：存在继承 / 实现关系、存在方法重写、父类引用指向子类对象
父类 引用名 = new 子类();
3.3多态弊端
父类引用无法直接调用子类独有的方法！
Animal a = new Dog();
// a.watch(); 报错！父类没有这个方法
解决方案：向下转型
向上转型（自动）：Animal a = new Dog();
向下转型（强制）：还原成子类类型
Dog d = (Dog) a;
d.watch();
类型转换异常风险 ClassCastException
使用 instanceof 判断类型再转换
if(a instanceof Dog){
Dog d = (Dog)a;
}
完整示例：
class Animal{ public void eat(){} } class Dog extends Animal{ @Override public void eat(){ System.out.println("狗吃骨头"); } public void watch(){ System.out.println("狗狗看门"); } } class Cat extends Animal{ @Override public void eat(){ System.out.println("猫吃鱼"); } } public class Demo{ public static void main(String[] args) { Animal ani = new Dog(); ani.eat(); // 判断是不是Dog类型再强转 if(ani instanceof Dog){ Dog dog = (Dog) ani; dog.watch(); } } }
4 抽象类
4.1父类只知道有这个功能，但是不清楚功能具体怎么实现，就可以定义为抽象方法。
包含抽象方法的类，必须声明为抽象类。
4.2 语法格式
abstract class 类名 {
// 抽象方法：没有方法体，只有声明
public abstract void 方法名();
}
4.3 示例
// 抽象父类 abstract class Animal { // 抽象方法，没有 {} public abstract void eat(); // 抽象类里可以拥有普通方法 public void sleep() { System.out.println("动物睡觉"); } } // 子类必须重写全部抽象方法 class Dog extends Animal { @Override public void eat() { System.out.println("狗吃骨头"); } }
4.4 核心规则
抽象类不能实例化（不能 new）
有抽象方法 → 类必须是 abstract 抽象类
抽象类不一定含有抽象方法
子类继承抽象类：要么重写所有抽象方法、要么子类也定义成抽象类
抽象方法不能被 private、static、final 修饰
final：方法不能重写，冲突
static：静态方法属于类，不能被子类重写
private：子类无法访问，不能重写
4.5 抽象类和普通父类区别
普通父类：所有方法都有实现
抽象类：可以规定子类必须实现哪些方法，起到强制规范作用
5.接口
5.1作用
接口是行为规范、标准，只定义功能，不关心具体实现。
抽象类侧重父子共性（is-a）；接口侧重具备某种能力（can-do）。
5.2语法
// 定义接口 interface 接口名 { // 抽象方法(JDK7及以前) public abstract void run(); } // 类实现接口，关键字 implements class 类名 implements 接口名{ // 必须重写接口所有抽象方法 }
5.3接口成员规则
抽象方法（默认 public abstract）
void test(); // 等价 public abstract void test();
常量（默认 public static final）
int MAX_NUM = 100;
JDK8 新增：默认方法 default，必须有方法体，允许重写
default void show(){
System.out.println("默认方法");
}
JDK8 新增：静态方法 static
只能用【接口名。方法名 ()】调用，实现类对象无法调用
6.内部类
定义：在一个类里面定义另一个类
外部类：外面的类
内部类：嵌套里面的类
分类：
成员内部类
局部内部类（了解）
匿名内部类
5.1 成员内部类
class Outer { private String name = "外部类"; // 成员内部类 class Inner { public void show() { // 内部类可以直接访问外部类所有成员，包括private System.out.println(name); } } } public class Test { public static void main(String[] args) { // 创建内部类对象格式 Outer.Inner in = new Outer().new Inner(); in.show(); } }
注意：
内部类可以直接访问外部类成员
外部类访问内部类，必须创建内部类对象
6.2匿名内部类
适用场景：只想临时实现接口 / 抽象类，不想单独新建一个类
本质：是一个没有名字的子类 / 实现类对象
语法格式：
new 接口/抽象类(){
重写抽象方法
};
背诵英语六级单词
积累词汇，巩固单词释义与搭配。
二、明天准备做什么
开启 Java 常用 API 板块学习，重点学习 String、StringBuilder，完成课堂代码练习。
继续背诵六级单词。

复盘今日面向对象易错知识点，整理笔记。
三、遇到的问题，如何解决
问题：容易混淆抽象类和接口的使用场景，分不清二者区别。
解决：整理对比表格，牢记核心设计思想：抽象类描述is-a事物共性，接口代表can-do扩展能力，结合案例反复对比理解；同时动手编写代码实操加深印象。