面向对象语法
1. 课程介绍
Ø 1.继承
Ø 2.方法覆写
Ø 3.Object类
Ø 4.访问权限修饰符
Java代码中：三大特性 ： 封装 继承 多态
2. 继承
2.1 继承概念的引入
1. 专业解释：
1) 泛化：在多个子类的基础上面抽取共有属性的行为到一个父类中去
2) 特化：在一个父类的基础上拓展子类特有的属性和行为，生成一个新的子类
3) 原则：父类存放共性，子类存放特性
2. 代码理解：
1) 三个类都有重复的代码，可以把公共这部分内容 抽出去，抽出去放到另外一个类里面；
a. 上面的类我们叫做 父类（超类，基类，根类）
2) 下面的3个类和上面的类需要发生一点关系【继承】
a. 下面的类我们叫做 子类（派生类，拓展类）
3. 提取好处 : 提高了代码的复用性
2.2 Java中类继承的基本语法
1. Java类中的继承的语法格式:
class Animal{}
class Person extends Animal{} //目标就是为了继承到Animal,这个类型
A 就是B的父类; B是A的子类
------------------------------------------------------------------------------
1) 没有导包Arrays:
2) class Tools extends java.util.Arrays{ }
3) 导包了Arrays
4) class Tools extends Arrays{ }
2. 验证:子类中是否可以继承到父类中的东西(通过创建子类对象来操作从父类继承的东西)
class Animal{
String name;
void eat(){
System.out.println("吃食物");
}
}
class Person extends Animal{
}
class Pig extends Animal{
}
测试类：
public class Test {
public static void main(String[] args) {
Person person = new Person();
person.name = "人胖";
System.out.println(person.name);
Pig pig = new Pig();
pig.eat();
}
}
2.3 子类可以从父类继承哪些成员？
1. 思考 : 一个父类中可能有哪些? 字段 普通方法 构造方法
2. 思考 : 可能还和访问权限有关 private public
3. 验证 :非私有的字段 和普通方法 可以被继承到（暂时这样记忆-主要是从是否可以访问的层面考虑）
4. 构造方法不能够被继承:java规定
5. 子类可以继承到父类的特性class MyFrame extends java.awt.Frame{}
class Person extends Animal{
Animal(){};
}
---------- Javac ----------
Test.java:20: 错误: 方法声明无效; 需要返回类型
Animal(){};
^
1 个错误
输出完成 (耗时 2 秒) - 正常终止
2.4 Java中类的继承特点
1. Java中类的继承只能够是单继承
2. 可以支持多重继承
3. 每一个类都有一个直接父类,如果没有看到显示的继承代码,那么就隐式继承就Object
2.5 继承总结
1. 继承的概念引入
2. 继承的基本语法
3. 继承到父类的那些东西
(1) 非私有的字段及方法
(2) 父类特性
4. 继承的特点
(1) 单继承
(2) 多重继承
(3) 没有显示的继承,那么隐式的继承Object
3. 方法覆写（覆盖，重写，Override）
3.1 为什么需要方法覆写
1.父类中有一个walk方法，每个子类都应该有
a) new Person().move();
b) new Snak().move();
2.实际情况
a) 不同的子类对于同一个移动的方法，表现形式不一样
b) 补充：子类的动态描述父类的动态描述不一致
3.怎么办
a) 把父类的方法拷贝到子类中，修改方法体，功能重新实现【覆盖，覆写Override】
3.2 方法覆写的基本语法
1. 明确为什么需要复写：当父类的方法不满足子类的需求的时候，需要覆写
2. 基本语法：直接将父类中需要覆写的方法复制放入子类，修改方法体
3. 子类方法是否在覆写父类的方法,可以通过注解@Override验证
(1) 是覆写:编译通过
(2) 不是覆写:编译报错
4. 注解理解
1) 注解:跟注释很类似
2) 注释:给程序员看的
3) 注解:给java程序看的
class Animal{
void move(){
System.out.println("移动");
}
}
class Person extends Animal{
void move(){//复制父类方法，方法体功能语句重新实现
System.out.println("走动");
}
}
3.3 方法覆写的细节
1. 方法的覆写语法细节：
1) 保证子类方法和父类方法的方法签名(方法名+参数列表)一致;
2) 访问权限 : 子类方法的访问权限(修饰符)不能够比父类方法的访问权限更低;
3) static 方法不能够被覆写
4) 返回值类型 : 子类方法的返回值类型可以是父类方法的返回值类型的子类或者相等
问题代码: int long根本不是类,int也不是long的子类
5) 方法主体 : 方法覆写,子类方法和父类方法主体是否可以一样, 可以! 但是没有什么用!
2. 方法覆写语法细节示例
3.4 方法覆写总结
1. 为什么需要方法复写
(1) 当父类的方法不满足子类的需求的时候需要复写
2. 方法复写的基本语法[ 最常用 ]
(1) 复制父类的方法到子类中,之后修改复制到子类中的方法体
(2) 是否是覆写可以通过注解@Override 写在子类被覆写的方法头,
① 是覆写编译通过
② 不是覆写编译报错
3. 方法复写的细节
4. Object类（及方法覆写的应用）
4.0 Object类引入
1. 每一个类都有一个直接父类,如果没有看到显示的继承代码,那么就隐式继承就Object
2. 理解：Object是每一个类的，直接父类或者间接父类
3. Object所有类的根类,是一个非常重要的类,所有类的重要的公共的静态属性，及动态行为[方法]都被提取到了Object
4. 结论：Object这个类必须要学习掌握
4.1 认识Object类
1. 类 Object 是类层次结构的根类,每个类都使用 Object 作为超类。[备注：接口没有关系]
2. 所有对象[包括数组]都实现这个类的方法 : 所有的对象[数组]都可以调用到Object中的方法;
3. 示例：
1) Student s = new Student();
s.hashCode(); 可以的
2) String s2 = “等等”;
s2.hashCode();可以的
3) int[] arr = new int[6];
arr.hashCode();可以的
4) int i = 5；//基本类型数据不是对象
i.hashCode();//不可以的
4.2 介绍Object类里面的方法
1. String toString() 返回调用此方法的当前对象的字符串表示形式(把当前对象转成字符串)
2. boolean equals(Object obj) 比较两个对象是否相等(比较调用此方法的对象是否和传入的obj”相等”)
3. int hashCode() 通过对象结合算法得到一个int值
4. Class<?> getClass() 返回此 Object 的运行时类(获得一个对象的真正的类型)
4.3 覆写Object中的方法-toString
1. String toString() 返回调用此方法的当前对象的字符串表示形式[把当前对象转成字符串]
2. 明确什么是对象描述：静态描述，姓名 年龄 ........
3. 实际打印地址值：不符合对于对象的描述
4. 暂时记住：打印语句打印对象，实际在调用父类toString方法，打印的对象描述，覆写完成分析怎么调用的
5. 父类toString方法返回结果，不符合子类需要打印对象描述的需求，所以覆写toString方法
class Test {
public static void main(String[] args) {
Student stu = new Student("小花花",18);
//System.out.println(stu);//覆写前：Student@15db9742
System.out.println(stu);//覆写后：小花花 - 18
}
}
class Student{
String name;
int age;
Student(String name,int age){
this.name = name;
this.age = age;
}
public String toString(){
return name + " - " +age;
}
}
6. 覆写toString方法的意义及什么时候需要覆写toString
a) 意义：自定类创建的对象可以准确的打印对象描述
b) 什么时候需要覆写：自定义类需要打印对象描述的时候
c) 了解：如果使用java中写好的类创建对象，打印的不是地址值，说明该类已经覆写过了toString
7. 通过分析打印语（System.out.println(stu)）句源码追踪分析打印对象，怎么使用的Object类中的toString方法
a) 分析原来怎么会打印地址值
b) 覆写之后为什么打印的是覆写后的对象描述:就近原则使用的是自己的toString
c) 注意：过程会存在以后知识点，认真听分析：重在理解
4.4 Object中的equals方法使用分析
Ø equals方法使用分析
1) 明确：boolean equals(Object obj) 比较两个对象是否相等(比较调用此方法的对象是否和传入的obj”相等”)
2) equals 方法使用，代码示例：
class Test {
public static void main(String[] args) {
Student stu1 = new Student("小花花",18);
Student stu2 = new Student("小花花",18);
boolean result = stu1.equals(stu2);
System.out.println(result);//false
}
}
class Student{
String name;
int age;
Student(String name,int age){
this.name = name;
this.age = age;
}
public String toString(){
return name + " - " +age;
}
}
1. 如上代码红色示例，比较结果为false
2. 比较结果为false的原因分析：实际Object中方法使用的是==比较：比较的是地址值！
3. 现实生活比较对象，姓名 年龄 身份证号，一样，即应该是同一个对象，不因为地址不同，就不是同一个人
4. 在java代码中：应该比较的是静态属性是否一致，如果一致则应该是同一个对象
5. Object中equals方法比较对象地址，不符合现实生活中比较对象的规则！java代码的对象比较，因该是静态属性的比较，父类Object中equals方法比较对象：不满足子类对象比较静态属性的需求，需要覆写
4.5覆写Object中的equals方法
版本一实现
1. boolean result = stu1.equals(stu2);
2. 分析：应该是调用方法的对象stu1与传入的对象stu2比较：比较的是静态属性
public boolean equals(Object obj){
if(this.name==obje.name&&this.age = age){
return true;
}else{
return false;
}
}
---------- Javac ----------
Test.java:18: 错误: 找不到符号
this.name==obj.name&&this.age == obj.age;
^ ^
符号: 变量 name
位置: 类型为Object的变量 obj编译器认为 ：obj
3. obj编译器只看类型不看值：obj为Object类型，没有name，age属性：
4. 但是我们知道obj变量中装的Student对象
5. 怎么办：把obj 转成Student [还原它的真实类型]
版本一完善 ：版本二实现
public boolean equals(Object obj){
Student stu = (Student)obj;
if(this.name==stu.name&&this.age = stu.age){
return true;
}else{
return false;
}
}
版本二完善 ：版本三实现
1. this.name Student中的name字段是String类型，有可能会比较引用地址，【有风险】
2. name字段是String类型的对象，对象的比较应该使用equals比较
public boolean equals(Object obj){
Student stu = (Student)obj;
if(this.name.equals(stu.name)&&this.age = stu.age){
return true;
}else{
return false;
}
}
版本三完善 ：
1. 上面if中 this.name.equals(stu.name)&&this.age==stu.age 本身结果就是布尔类型的值，没必要写if结构
public boolean equals(Object obj){
Student stu = (Student)obj;
return this.name.equals(stu.name)&&this.age = stu.age;
}
1. 什么时候需要覆写Object中的equals方法,及覆写的意义
(1) 什么时候需要覆写自定义类对象,相互之间需要比较对象的静态属性的时候!
(2) 覆写的意义:能够需求,正确的比较对象,静态属性
2. 小结toString equals,当真正覆写的时候,注意,根据需要用,哪些字段!
4.6 == 和 equals区别[面试题]
1. == 和 equals 都是比较是否相等,请问它们到底有什么区别呢?
相等 : a 传统的理解一般都是数字值是否相等;
b 在程序中任何东西都是数据,都会比较是否相等[ 对象 ]
2. == 比较运算符
1) 基本数据类型变量: 比较的就是值是否相等;
2) 引用数据类型变量: 比较的是对象的地址是否一样;（排除特殊 String）
3. equals 方法[最初定义在根类Object中的,比较对象是否相等]
1) 基本数据类型 : 不能够使用! 基本数据类型不是对象,不能够调用Object中的方法
2) 引用数据类型 : 但是在Object的源码中定义的就是 == 进行比较比较
4. 定义好的类没有覆写过equals方法，则会直接调用到了Object中的equals方法,那么本质还是在使用==比较
5. 在实际开发中,自定义类：一般比较对象，都是通过对象的属性值进行比较,所以自定义类，会经常覆写Object中的此方法,把自己的比较规则写在方法里面;
6. 覆写equals方法的意义：定义类，覆写equals方法，自己制定规则，比较自定义类对象的静态属性
5. 访问权限修饰符
5.1 什么是权限修饰符及作用
1. 权限修饰符 ： private < 默认不写（注意不要添加default修饰）< protected < public
2. 作用 ： 主要是控制类以及类中成员的访问权限
5.2 测试修饰内容
1. 要知道哪些东西能被修饰：主要是修饰类中的成员（字段 方法 构造方法， 内部类）;
1) public 默认 ①可以修饰类[内部类 和 外部类]
2) private protected ①不能够修饰类外部类
3) 都不能够修饰局部变量
5.3 访问权限列表
|
同一个类中的成员 |
同一个包中的成员 |
不同包但存在继承的子类 |
全局 |
|
|
private(私有) |
√ |
|||
|
默认不写 |
√ |
√ |
||
|
protected(受保护) |
√ |
√ |
√ |
|
|
public(公共) |
√ |
√ |
√ |
√ |
5.4 权限修饰符测试
5.5 权限修饰符使用原则
1. 肯定记不住所有的访问的权限的情况：应该怎么去用权限修饰符：
1) 如果不希望别访问，私有化private权限
2) 如果希望别人访问，提供公共的权限public
3) 如果特殊情况：权限由小到大设置
5.6 访问权限总结
1. 权限修饰符的概念：private < 默认不写 <protected < public
作用: 控制类及类中的成员能否被访问
2. 权限修饰符有哪些
3. 权限修饰符可以修饰内容的测试
4. 权限使用的规则
5. 自己会测试权限测试
1. 课程总结
1.1. 重点
1.2. 难点
知识点较多，相关性不大，
1.3. 如何掌握？
总结
2. 课后练习[45分钟]
第一题：static 可以修饰什么？有static修饰的字段和方法，应该怎样访问？
第二题：public static void 可以写成 static public void 这样?
第三题：包怎么导入，怎么申明？
第四题：为什么需要复写方法，
覆写toString 的意义，及什么时候需要覆写toString
覆写equals的意义，及什么时候需要覆写equals
第五题：==和equals的 区别
第六题：权限修饰符的概念使用原则是什么
3. 面试题
4. 扩展知识或课外阅读推荐（可选）
1.4. 扩展知识
面向对象语法
1. 课程介绍
Ø 1.继承
Ø 2.方法覆写
Ø 3.Object类
Ø 4.访问权限修饰符
Java代码中：三大特性 ： 封装 继承 多态
2. 继承
2.1 继承概念的引入
1. 专业解释：
1) 泛化：在多个子类的基础上面抽取共有属性的行为到一个父类中去
2) 特化：在一个父类的基础上拓展子类特有的属性和行为，生成一个新的子类
3) 原则：父类存放共性，子类存放特性
2. 代码理解：
1) 三个类都有重复的代码，可以把公共这部分内容 抽出去，抽出去放到另外一个类里面；
a. 上面的类我们叫做 父类（超类，基类，根类）
2) 下面的3个类和上面的类需要发生一点关系【继承】
a. 下面的类我们叫做 子类（派生类，拓展类）
3. 提取好处 : 提高了代码的复用性
2.2 Java中类继承的基本语法
1. Java类中的继承的语法格式:
class Animal{}
class Person extends Animal{} //目标就是为了继承到Animal,这个类型
A 就是B的父类; B是A的子类
------------------------------------------------------------------------------
1) 没有导包Arrays:
2) class Tools extends java.util.Arrays{ }
3) 导包了Arrays
4) class Tools extends Arrays{ }
2. 验证:子类中是否可以继承到父类中的东西(通过创建子类对象来操作从父类继承的东西)
class Animal{
String name;
void eat(){
System.out.println("吃食物");
}
}
class Person extends Animal{
}
class Pig extends Animal{
}
测试类：
public class Test {
public static void main(String[] args) {
Person person = new Person();
person.name = "人胖";
System.out.println(person.name);
Pig pig = new Pig();
pig.eat();
}
}
2.3 子类可以从父类继承哪些成员？
1. 思考 : 一个父类中可能有哪些? 字段 普通方法 构造方法
2. 思考 : 可能还和访问权限有关 private public
3. 验证 :非私有的字段 和普通方法 可以被继承到（暂时这样记忆-主要是从是否可以访问的层面考虑）
4. 构造方法不能够被继承:java规定
5. 子类可以继承到父类的特性class MyFrame extends java.awt.Frame{}
class Person extends Animal{
Animal(){};
}
---------- Javac ----------
Test.java:20: 错误: 方法声明无效; 需要返回类型
Animal(){};
^
1 个错误
输出完成 (耗时 2 秒) - 正常终止
2.4 Java中类的继承特点
1. Java中类的继承只能够是单继承
2. 可以支持多重继承
3. 每一个类都有一个直接父类,如果没有看到显示的继承代码,那么就隐式继承就Object
2.5 继承总结
1. 继承的概念引入
2. 继承的基本语法
3. 继承到父类的那些东西
(1) 非私有的字段及方法
(2) 父类特性
4. 继承的特点
(1) 单继承
(2) 多重继承
(3) 没有显示的继承,那么隐式的继承Object
3. 方法覆写（覆盖，重写，Override）
3.1 为什么需要方法覆写
1.父类中有一个walk方法，每个子类都应该有
a) new Person().move();
b) new Snak().move();
2.实际情况
a) 不同的子类对于同一个移动的方法，表现形式不一样
b) 补充：子类的动态描述父类的动态描述不一致
3.怎么办
a) 把父类的方法拷贝到子类中，修改方法体，功能重新实现【覆盖，覆写Override】
3.2 方法覆写的基本语法
1. 明确为什么需要复写：当父类的方法不满足子类的需求的时候，需要覆写
2. 基本语法：直接将父类中需要覆写的方法复制放入子类，修改方法体
3. 子类方法是否在覆写父类的方法,可以通过注解@Override验证
(1) 是覆写:编译通过
(2) 不是覆写:编译报错
4. 注解理解
1) 注解:跟注释很类似
2) 注释:给程序员看的
3) 注解:给java程序看的
class Animal{
void move(){
System.out.println("移动");
}
}
class Person extends Animal{
void move(){//复制父类方法，方法体功能语句重新实现
System.out.println("走动");
}
}
3.3 方法覆写的细节
1. 方法的覆写语法细节：
1) 保证子类方法和父类方法的方法签名(方法名+参数列表)一致;
2) 访问权限 : 子类方法的访问权限(修饰符)不能够比父类方法的访问权限更低;
3) static 方法不能够被覆写
4) 返回值类型 : 子类方法的返回值类型可以是父类方法的返回值类型的子类或者相等
问题代码: int long根本不是类,int也不是long的子类
5) 方法主体 : 方法覆写,子类方法和父类方法主体是否可以一样, 可以! 但是没有什么用!
2. 方法覆写语法细节示例
3.4 方法覆写总结
1. 为什么需要方法复写
(1) 当父类的方法不满足子类的需求的时候需要复写
2. 方法复写的基本语法[ 最常用 ]
(1) 复制父类的方法到子类中,之后修改复制到子类中的方法体
(2) 是否是覆写可以通过注解@Override 写在子类被覆写的方法头,
① 是覆写编译通过
② 不是覆写编译报错
3. 方法复写的细节
4. Object类（及方法覆写的应用）
4.0 Object类引入
1. 每一个类都有一个直接父类,如果没有看到显示的继承代码,那么就隐式继承就Object
2. 理解：Object是每一个类的，直接父类或者间接父类
3. Object所有类的根类,是一个非常重要的类,所有类的重要的公共的静态属性，及动态行为[方法]都被提取到了Object
4. 结论：Object这个类必须要学习掌握
4.1 认识Object类
1. 类 Object 是类层次结构的根类,每个类都使用 Object 作为超类。[备注：接口没有关系]
2. 所有对象[包括数组]都实现这个类的方法 : 所有的对象[数组]都可以调用到Object中的方法;
3. 示例：
1) Student s = new Student();
s.hashCode(); 可以的
2) String s2 = “等等”;
s2.hashCode();可以的
3) int[] arr = new int[6];
arr.hashCode();可以的
4) int i = 5；//基本类型数据不是对象
i.hashCode();//不可以的
4.2 介绍Object类里面的方法
1. String toString() 返回调用此方法的当前对象的字符串表示形式(把当前对象转成字符串)
2. boolean equals(Object obj) 比较两个对象是否相等(比较调用此方法的对象是否和传入的obj”相等”)
3. int hashCode() 通过对象结合算法得到一个int值
4. Class<?> getClass() 返回此 Object 的运行时类(获得一个对象的真正的类型)
4.3 覆写Object中的方法-toString
1. String toString() 返回调用此方法的当前对象的字符串表示形式[把当前对象转成字符串]
2. 明确什么是对象描述：静态描述，姓名 年龄 ........
3. 实际打印地址值：不符合对于对象的描述
4. 暂时记住：打印语句打印对象，实际在调用父类toString方法，打印的对象描述，覆写完成分析怎么调用的
5. 父类toString方法返回结果，不符合子类需要打印对象描述的需求，所以覆写toString方法
class Test {
public static void main(String[] args) {
Student stu = new Student("小花花",18);
//System.out.println(stu);//覆写前：Student@15db9742
System.out.println(stu);//覆写后：小花花 - 18
}
}
class Student{
String name;
int age;
Student(String name,int age){
this.name = name;
this.age = age;
}
public String toString(){
return name + " - " +age;
}
}
6. 覆写toString方法的意义及什么时候需要覆写toString
a) 意义：自定类创建的对象可以准确的打印对象描述
b) 什么时候需要覆写：自定义类需要打印对象描述的时候
c) 了解：如果使用java中写好的类创建对象，打印的不是地址值，说明该类已经覆写过了toString
7. 通过分析打印语（System.out.println(stu)）句源码追踪分析打印对象，怎么使用的Object类中的toString方法
a) 分析原来怎么会打印地址值
b) 覆写之后为什么打印的是覆写后的对象描述:就近原则使用的是自己的toString
c) 注意：过程会存在以后知识点，认真听分析：重在理解
4.4 Object中的equals方法使用分析
Ø equals方法使用分析
1) 明确：boolean equals(Object obj) 比较两个对象是否相等(比较调用此方法的对象是否和传入的obj”相等”)
2) equals 方法使用，代码示例：
class Test {
public static void main(String[] args) {
Student stu1 = new Student("小花花",18);
Student stu2 = new Student("小花花",18);
boolean result = stu1.equals(stu2);
System.out.println(result);//false
}
}
class Student{
String name;
int age;
Student(String name,int age){
this.name = name;
this.age = age;
}
public String toString(){
return name + " - " +age;
}
}
1. 如上代码红色示例，比较结果为false
2. 比较结果为false的原因分析：实际Object中方法使用的是==比较：比较的是地址值！
3. 现实生活比较对象，姓名 年龄 身份证号，一样，即应该是同一个对象，不因为地址不同，就不是同一个人
4. 在java代码中：应该比较的是静态属性是否一致，如果一致则应该是同一个对象
5. Object中equals方法比较对象地址，不符合现实生活中比较对象的规则！java代码的对象比较，因该是静态属性的比较，父类Object中equals方法比较对象：不满足子类对象比较静态属性的需求，需要覆写
4.5覆写Object中的equals方法
版本一实现
1. boolean result = stu1.equals(stu2);
2. 分析：应该是调用方法的对象stu1与传入的对象stu2比较：比较的是静态属性
public boolean equals(Object obj){
if(this.name==obje.name&&this.age = age){
return true;
}else{
return false;
}
}
---------- Javac ----------
Test.java:18: 错误: 找不到符号
this.name==obj.name&&this.age == obj.age;
^ ^
符号: 变量 name
位置: 类型为Object的变量 obj编译器认为 ：obj
3. obj编译器只看类型不看值：obj为Object类型，没有name，age属性：
4. 但是我们知道obj变量中装的Student对象
5. 怎么办：把obj 转成Student [还原它的真实类型]
版本一完善 ：版本二实现
public boolean equals(Object obj){
Student stu = (Student)obj;
if(this.name==stu.name&&this.age = stu.age){
return true;
}else{
return false;
}
}
版本二完善 ：版本三实现
1. this.name Student中的name字段是String类型，有可能会比较引用地址，【有风险】
2. name字段是String类型的对象，对象的比较应该使用equals比较
public boolean equals(Object obj){
Student stu = (Student)obj;
if(this.name.equals(stu.name)&&this.age = stu.age){
return true;
}else{
return false;
}
}
版本三完善 ：
1. 上面if中 this.name.equals(stu.name)&&this.age==stu.age 本身结果就是布尔类型的值，没必要写if结构
public boolean equals(Object obj){
Student stu = (Student)obj;
return this.name.equals(stu.name)&&this.age = stu.age;
}
1. 什么时候需要覆写Object中的equals方法,及覆写的意义
(1) 什么时候需要覆写自定义类对象,相互之间需要比较对象的静态属性的时候!
(2) 覆写的意义:能够需求,正确的比较对象,静态属性
2. 小结toString equals,当真正覆写的时候,注意,根据需要用,哪些字段!
4.6 == 和 equals区别[面试题]
1. == 和 equals 都是比较是否相等,请问它们到底有什么区别呢?
相等 : a 传统的理解一般都是数字值是否相等;
b 在程序中任何东西都是数据,都会比较是否相等[ 对象 ]
2. == 比较运算符
1) 基本数据类型变量: 比较的就是值是否相等;
2) 引用数据类型变量: 比较的是对象的地址是否一样;（排除特殊 String）
3. equals 方法[最初定义在根类Object中的,比较对象是否相等]
1) 基本数据类型 : 不能够使用! 基本数据类型不是对象,不能够调用Object中的方法
2) 引用数据类型 : 但是在Object的源码中定义的就是 == 进行比较比较
4. 定义好的类没有覆写过equals方法，则会直接调用到了Object中的equals方法,那么本质还是在使用==比较
5. 在实际开发中,自定义类：一般比较对象，都是通过对象的属性值进行比较,所以自定义类，会经常覆写Object中的此方法,把自己的比较规则写在方法里面;
6. 覆写equals方法的意义：定义类，覆写equals方法，自己制定规则，比较自定义类对象的静态属性
5. 访问权限修饰符
5.1 什么是权限修饰符及作用
1. 权限修饰符 ： private < 默认不写（注意不要添加default修饰）< protected < public
2. 作用 ： 主要是控制类以及类中成员的访问权限
5.2 测试修饰内容
1. 要知道哪些东西能被修饰：主要是修饰类中的成员（字段 方法 构造方法， 内部类）;
1) public 默认 ①可以修饰类[内部类 和 外部类]
2) private protected ①不能够修饰类外部类
3) 都不能够修饰局部变量
5.3 访问权限列表
|
同一个类中的成员 |
同一个包中的成员 |
不同包但存在继承的子类 |
全局 |
|
|
private(私有) |
√ |
|||
|
默认不写 |
√ |
√ |
||
|
protected(受保护) |
√ |
√ |
√ |
|
|
public(公共) |
√ |
√ |
√ |
√ |
5.4 权限修饰符测试
5.5 权限修饰符使用原则
1. 肯定记不住所有的访问的权限的情况：应该怎么去用权限修饰符：
1) 如果不希望别访问，私有化private权限
2) 如果希望别人访问，提供公共的权限public
3) 如果特殊情况：权限由小到大设置
5.6 访问权限总结
1. 权限修饰符的概念：private < 默认不写 <protected < public
作用: 控制类及类中的成员能否被访问
2. 权限修饰符有哪些
3. 权限修饰符可以修饰内容的测试
4. 权限使用的规则
5. 自己会测试权限测试
1. 课程总结
1.1. 重点
1.2. 难点
知识点较多，相关性不大，
1.3. 如何掌握？
总结
2. 课后练习[45分钟]
第一题：static 可以修饰什么？有static修饰的字段和方法，应该怎样访问？
第二题：public static void 可以写成 static public void 这样?
第三题：包怎么导入，怎么申明？
第四题：为什么需要复写方法，
覆写toString 的意义，及什么时候需要覆写toString
覆写equals的意义，及什么时候需要覆写equals
第五题：==和equals的 区别
第六题：权限修饰符的概念使用原则是什么
3. 面试题
4. 扩展知识或课外阅读推荐（可选）
1.4. 扩展知识
1.5. 课外阅读
5. 每日一练【20分钟】
1. 练习方法的定义及使用
2. 练习查看API使用数组工具类Arrays
1.5. 课外阅读
5. 每日一练【20分钟】
1. 练习方法的定义及使用
2. 练习查看API使用数组工具类Arrays