- 第7章 面向对象编程（基础部分）
- 类与对象
- 成员方法
- 成员方法传参机制（！！！）
- 方法递归调用（！！！）
- 方法重载(OverLoad)
- 可变参数
- 作用域
- 构造方法/构造器
- 对象创建的流程分析
- this关键字
- 第8章 面向对象编程(中级部分)
- IDE(集成开发环境) -IDEA
- IDE(集成开发环境) -Eclipse
- IDE(集成开发环境) -IDEA的使用
- 包
- 访问修饰符
- 面向对象编程三大特征
- 面向对象编程-封装
- 面向对象编程-继承
- super关键字
- 方法重写/覆盖 (override)
- 面向对象编程-多态
- Object类详解
- 日期
-
使用现有技术解决
1)单独的定义变量解决
2)使用数组解决 -
现有技术解决的缺点分析
不利于数据的管理
效率低 -
类与对象的关系示意图
-
类和对象的区别和联系
1）类是抽象的，概念的，代表一类事物，比如人类，猫类…,即它是数据类型
2）对象是具体的，实际的，代表一个具体事物，即是实例
3）类是对象的模板，对象是类的一个个体，对应一个实例 -
对象在内存中存在形式（重要）
-
属性/成员变量
√基本介绍
1.从概念或叫法上看：成员变量 = 属性 = field（字段）（即 成员变量是用来表示属性的，授课中，统一叫属性）例如：Car(name,price,color)
2.属性是类的一个组成部分，一般是基本数据类型，也可是引用类型（对象，数组）。比如我们前面定义猫类的int age就是属性
√注意事项和细节说明
1）属性的定义语法同变量，示例：访问修饰符 属性类型 属性名；
访问修饰符：控制属性的访问范围
有四种访问修饰符 public，proctected,默认，private
2）属性的定义类型可以为任意类型，包含基本类型或引用类型
3）属性如果不赋值，有默认值，规则和数组一致。
-
如何创建对象
1.先声明再创建
Cat cat;
cat = new Cat();
2.直接创建
Cat cat = new Cat(); -
如何访问属性
√基本语法
对象名.属性名; -
类和对象的内存分配机制（重要）
√Java内存的结构分析
1.栈：一般存放基本数据类型（局部变量）
2.堆：存放对象（Cat cat,数组等）
3.方法区：常量池（常量，比如字符串），类加载信息
√Java创建对象的流程简单分析
Person p = new Person();
p.name = "jack";
p.age = 10;
1.先加载Person类信息（属性和方法信息，只会加载一次）
2.在堆中分配空间，进行默认初始化（看规则）
3.把地址赋给p，p就指向对象
4.进行指定初始化，比如p.name = “jack”; p.age = 10;
-
基本介绍
在某些情况下，我们需要定义成员方法（简称方法）。比如人类：除了有一些属性外（年龄，姓名…）,我们人类还有一些行为比如：可以说话、跑步…通过学习，还可以做算术题，这时就要用成员方法才能完成。 -
成员方法快速入门
实例：
1）添加speak 成员方法，输出 我是一个好人
2）添加cal01成员方法，可以计算从1+…+1000的结果
3）添加cal02成员方法，该方法可以接收一个数n，计算从1+…+n的结果
4）添加getSum成员方法，可以计算两个数的和 -
方法的调用机制原理（程序getSum的执行过程）
-
为什么需要成员方法
√看一个需求：
请遍历一个数组，输出数组的各个元素值。
解决思路1：传统方法，就是使用单个for循环，将数组输出（问题：相同代码的重复）
解决思路2：定义一个类MyTools，然后写一个成员方法，调用方法实现 -
成员方法的好处
√提高代码的复用性
√可以将实现的细节封装起来，然后供其他用户来调用即可。 -
成员方法的定义
-
注意事项和使用细节
√访问修饰符（作用是控制方法使用的范围）
如果不写默认访问，[有四种：public,protected,默认,private]
√返回数据类型
1.一个方法最多有一个返回值（多个值考虑使用数组）
2.返回类型可以为任意类型，包含基本类型或引用类型（数组，对象）
3.如果方法要求有返回数据类型，则方法体中最后执行语句必须为return值；而且要求返回值类型必须和return的值类型一致或兼容
4.如果方法是void，则方法体中可以没有return语句，或者只写return；
2对应实例：
class AA{
public int[] getSumAndSub(int n1,int n2){
int[] resArr = new int[2]; //创建一个数组
resArr[0] = n1 + n2;
resArr[1] = n1 - n2;
return resArr;
}
}
√方法名
遵循驼峰命名法，最好见名知义，表达出该功能的意思即可，比如 得到两个数的和getSum，开发中按照规范
√形参列表
- 一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开，比如getSum(int n1, int n2)
- 参数类型可以为任意类型，包含基本类型或引用类型，比如printArr（int[][] map）
- 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数!【getSum】
- 方法定义时的参数称为形式参数，简称形参；方法调用时的传入参数称为实际参数，简称实参，实参和形参的类型要一致或兼容、个数、顺序必须一致！
√方法体
里面写完成功能的具体的语句，可以为输入、输出、变量、运算、分支、循环、方法调用，但里面不能再定义方法！即：方法不能嵌套定义。
√方法调用细节说明
1.同一类中的方法调用：直接调用即可。
2.跨类中的方法A类调用B类方法：需要通过对象名调用。比如对象名.方法名（参数);
3.特别说明一下：跨类的方法调用和方法的访问修饰符相关
实例：
class A{
//同一个类中的方法调用：直接调用即可
//可执行
public void print(int n){
System.out.println("print()方法被调用 n=" + n);
}
public void sayOk(){ //sayok调用 print(直接调用)
print(10);
System.out.println("继续执行sayOk()~~~~");
}
//跨类中的方法A类调用B类方法：需要通过对象名调用。比如对象名.方法名（参数);
public void m1(){
//创建B对象,然后再调用方法即可
System.out.println("m1()方法被调用");
B b = new B();
b.hi();
System.out.println("m1()继续执行");
}
}
class B{
public void hi(){
System.out.println("B类中的hi()被执行");
}
}
- 基本数据类型的传参机制
基本数据类型，传递的是值（值拷贝），形参的任何改变不影响实参！ - 引用数据类型的传参机制
引用类型传递的是地址（传递也是值，但是值是地址），可以通过形参影响实参！
实例:
public class MethodParameter02{
//编写一个main方法
public static void main(String[] args){
B b = new B();
//测试
Person p = new Person();
p.name = "jack";
p.age = 10;
b.test200(p);
//测试题，如果test200执行p = null;下面结果是10
//测试题，如果test200执行p = new Person();下面结果是10
System.out.println("main 的p.age=" + p.age); //如果test200执行p.age = 10000; 下面结果为10000
}
}
class Person{
String name;
int age;
}
class B{
public void test200(Person p){
//p.age = 10000;
//思考
//p = null;
//思考
p = new Person();
p.name = "tom";
p.age = 99;
}
}
-
基本介绍
递归就是方法自己调用自己，每次调用时传入不同的变量。递归有助于编程者解决复杂问题，同时可以让代码变得简洁。 -
递归能解决什么问题？
1.各种数学问题如：8皇后问题，汉诺塔，阶乘问题，迷宫问题，球和篮子的问题（google编程大赛）
2.各种算法中也会使用递归，比如快排，归并排序，二分查找，分治算法等。
3.将用栈解决的问题–>递归代码比较简洁
递归调用实例：
public class Recursion01{
//编写一个main方法
public static void main(String[] args){
T t1 = new T();
t1.test(4); //输出什么？
}
}
class T{
//分析
public void test(int n){
if(n > 2){
test(n - 1);
}
System.out.println("n=" + n);
}
}
过程分析
运行结果：
- 递归重要规则
1.执行一个方法时，就 创建一个新的受保护的独立空间（栈空间）
2.方法的局部变量是独立的，不会相互影响，比如n变量
3.如果方法中使用的是引用类型变量（比如数组），就会共享该引用类型
4.递归必须向退出递归的条件逼近，否则就是无限递归。
5.当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。
递归调用实例-老鼠迷宫问题：
1.老鼠初始位置（1,1）红色球代表老鼠（位置表示用二维数组）
2.老鼠找路策略 下->右->上->左
3.出口位置（5,6）
代码：
public class MiGong{
//编写一个main的方法
public static void main(String[] args){
//思路
//1.先创建迷宫，用二维数组表示int[][] map = new int[8][7];
//2.先规定map数组的元素值：0表示可以走 1表示障碍物
int[][] map = new int[8][7];
//3.将最上面的一行和最下面的一行，全部设置为1
for(int i = 0; i < 7; i++){
map[0][i] = 1;
map[7][i] = 1;
}
//4.将最右面的一列和最左面的一列，全部设置为1
for(int i = 0; i < 8; i++){
map[i][0] = 1;
map[i][6] = 1;
}
map[3][1] = 1;
map[3][2] = 1;
//输出当前的地图
System.out.println("=====当前地图情况=====");
for(int i = 0; i < map.length; i++){
for(int j = 0; j < map[i].length; j++){
System.out.print(map[i][j] + " "); //输出一行
}
System.out.println();
}
//使用findWay给老鼠找路
T t1 = new T();
t1.findWay(map, 1, 1);
System.out.println("\n=====找路的情况如下=====");
for(int i = 0; i < map.length; i++){
for(int j = 0; j < map[i].length; j++){
System.out.print(map[i][j] + " "); //输出一行
}
System.out.println();
}
}
}
class T {
//使用递归回溯的思想来解决老输出迷宫
//老韩解读
//1.findWay方法就是专门来找出迷宫的路径
//2.如果找到,就返回true,否则返回false
//3.Map就是二维数组,即表示迷宫
//4.i,j就是老鼠的位置，初始化的位置为(1,1)
//5.因为我们是递归的找路，所以我先规定map数组的各个值的含义
// 0表示可以走1表示障碍物,2表示先假定可以走3表示走过，但是走不通是死路
//6.当map[6][5] = 2 就说明找到通路,就可以结束,否则就继续找
//7.先确定老鼠找路策略 下->右->上->左
public boolean findWay(int[][] map, int i, int j){
if(map[6][5] == 2){//说明已经找到
return true;
}else{
if(map[i][j] == 0){//当前这个位置0,说明表示可以走
//我们假定可以走通
map[i][j] = 2;
//使用找路策略,来确定该位置是否真的可以走通
if(findWay(map, i + 1, j)){ //先走下
return true;
}else if(findWay(map, i, j + 1)){//右
return true;
}else if(findWay(map, i - 1, j)){//向上
return true;
}else if(findWay(map, i, j - 1)){//向左
return true;
}else {
map[i][j] = 3;
return false;
}
}else{//map[i][j] = 1, 2, 3
return false;
}
}
}
}
运行结果：
递归调用实例-汉诺塔：
汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创建世界的时候做了3跟金刚石柱子，在一根柱子从下往上按照大小顺序摞着64片圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。
代码：
public class HanoiTower{
//编写一个main方法
public static void main(String[] args){
Tower tower = new Tower();
tower.move(5, 'A', 'B', 'C');
}
}
class Tower {
//方法
//num表示要移动的个数,a,b,c分别表示A塔，B塔，C塔
public void move(int num, char a, char b , char c){
//如果只有一个盘 num = 1
if(num == 1){
System.out.println(a + "->" + c);
}else{
//如果有多个盘，可以看成两个，最下面的和最上面的所有盘(num-1个)
//(1)先移动上面所有的盘到b，借助c
move(num - 1, a, c, b);
//(2)把最下面的这个盘，移动到c
System.out.println(a + "->" + c);
//(3)再把b塔的所有盘，移动到c，借助a
move(num - 1, b, a, c);
}
}
}
结果(5片圆盘的搬运过程)：
- 基本介绍
java中允许同一个类中，多个同名方法的存在，但要求形参列表不一致！比如：System.out.println();out 是PrintStream类型
（可以通过此语句打印不同类型数据，即方法中的形参不同） - 重载的好处
1）减轻了起名的麻烦
2）减轻了记名的麻烦
重载实例：
public class OverLoad01{
//编写一个main方法
public static void main(String[] args){
MyCalculator mc = new MyCalculator();
System.out.println(mc.calculate(1,2));
System.out.println(mc.calculate(1.1,2));
System.out.println(mc.calculate(1,2.2));
System.out.println(mc.calculate(1,2,3));
}
}
class MyCalculator{
//两个int的和
public int calculate(int n1, int n2){
return n1 + n2;
}
//一个int，一个double的和
public double calculate(int n1, double n2){
return n1 + n2;
}
//一个double，一个int的和
public double calculate(double n2, int n1){
return n1 + n2;
}
//三个int的和
public int calculate(int n1, int n2, int n3){
return n1 + n2 + n3;
}
}
运行结果：
- 注意事项和使用细节
1）方法名：必须相同
2）形参列表：必须不同（参数类型或个数或顺序，至少有一样不同，参数名无要求）
3）返回类型：无要求
-
基本概念
java允许将同一类中多个同名同功能但参数个数不同的方法，封装成一个方法。就可以通过可变参数实现。 -
基本语句
访问修饰符 返回类型 方法名（数据类型…形参名）{
}
实例（求多个数的和):
public class VarParameter01{
//编写一个main方法
public static void main(String[] args){
HspMethod m = new HspMethod();
System.out.println(m.sum(1, 5, 100)); //106
System.out.println(m.sum(1, 19)); //20
}
}
class HspMethod{
//1.int...表示接受的是可变参数,类型是int，既可以接收多个int(0-多)
//2.使用可变参数时候，可以当做数组来使用,即nums可以当做数组
//3.遍历nums求和即可
public int sum(int... nums){
System.out.println("接收的参数个数=" + nums.length);
int res = 0;
for(int i = 0; i < nums.length; i++){
res += nums[i];
}
return res;
}
}
运算结果：
- 注意事项和使用细节
1）可变参数的实参可以为0个或任意多个
2）可变参数的实参可以为数组
3）可变参数的本质就是数组
4）可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
5)一个形参列表中只能出现一个可变参数
- 基本使用
面向对象中，变量作用域是非常重要的知识点。
1.在java编程中，主要的变量就是属性(成员变量)和局部变量
2.我们说的局部变量一般是指在成员方法中定义的变量。
3.java中作用域的分类
全局变量：也就是属性，作用域为整体类型Cat类：cry eat 等方法使用属性【举例】局部变量：也就是除了属性之外的其他变量，作用域为定义他的代码块中！
4.全局变量可以不赋值，直接使用，因为有默认值，局部变量必须赋值后，才能使用，因为没有默认值。
- 注意事项和细节使用
1.属性和局部变量可以重名，访问时遵循就近原则
2.在同一个作用域中，比如在同一个成员方法中，两个局部变量，不能重名。
3.属性生命周期较长，伴随着对象的创建而创建，伴随着对象
的销毁而销毁。局部变量，生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁。即在一次方法调用过程中。
4.作用域范围不同
全局变量/属性：可以被本类使用，或其他类使用（通过对象调用）局部变量：只能在本类中对应的方法中使用
5.修饰符不同
全局变量/属性可以加修饰符
局部变量不可以加修饰符
实例：
public class VarScopedetail{
//编写一个main方法
public static void main(String[] args){
Person p1 = new Person();
/*
属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。
局部变量，生命周期较短，伴随着它的代码块的执行而创建，
伴随着代码块的结束而销毁。即在一次方法调用过程中。
*/
p1.say(); //当执行say方法时，say方法的局部变量比如name，会创建，当say执行完毕后
//name局部变量就销毁，但是属性(全局变量)仍然可以使用
}
}
class Person{
String name = "jack";
public void say(){
//细节：属性和局部变量可以重名，访问时遵循就近原则
String name = "king";
System.out.println("say() name=" + name);
}
public void hi(){
String address = "北京";
//String sddress = "上海"; //错误，重复定义变量
String name = "hsp"; //可以
}
}
运行结果：
-
基本介绍
构造方法又叫构造器(constructor),是类的一种特殊的方法，它的主要作用是完成对新对象的初始化，它有几个特点：
1）方法名和类名相同
2）没有返回值
3）在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。 -
基本语法
[修饰符]方法名(形参列表){
方法体；
}
- 构造器的修饰付可以默认，也可以是public protected private
- 构造器没有返回值
- 方法名和类名字必须一样
- 参数列表和成员方法一样的规则
- 构造器的调用，由系统完成
实例：
public class Constructor01{
//编写一个main方法
public static void main(String[] args){
//当我们new一个对象时，直接通过构造器制定名字和年龄
Person p1 = new Person("smith", 80);
System.out.println("p1的信息如下");
System.out.println("p1对象name=" + p1.name); //smith
System.out.println("p1对象age=" + p1.age); //80
}
}
//在创建人类对象时，就直接指定这个对象的年龄和姓名
//
class Person{
String name;
int age;
//构造器
//老韩解读
//1.构造器没有返回值，也不能写void
//2.构造器的名称和类Person一样
//3.(String pName, int pAge)是构造器形参列表，规则和成员方法一样
public Person(String pName, int pAge){
System.out.println("构造器被调用~~ 完成对象的属性初始化");
name = pName;
age = pAge;
}
}
运算结果：
- 注意事项和使用细节
1.一个类可以定义多个不同的构造器，及构造器重载
比如：我们可以再给Person类定义一个构造器，用来创建对象的时候，只指定人名，不需要指定年龄
2.构造器名和类名要相同
3.构造器没有返回值
4.构造器是完成对象的初始化，并不是创建对象
5.在创建对象时，系统自动的调用该类的构建方法
6.如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造方法（也叫默认构造器），比如Person（）{}，使用javap指令反编译看看
7.一旦定义了自己的构造器，默认的构造器就覆盖了，就不能再使用默认的无参构造器，除非显式的定义一下，即：Person（）{}
- 流程分析
1.加载Person类信息（Person.class),只会加载一次
2.在堆中分配空间（地址）
3.完成对象初始化[3.1默认初始化age = 0 name = null 3.2显式初始化age =90，name = null,3.3构造器的初始化age = 20,name = 小倩]
4.对象在堆中的地址，返回给p（p是对象名，也可以理解成对象的引用）
-
什么是this
java虚拟机会给每个对象分配this，代表当前对象。 -
this的注意事项和使用细节
1)this关键字可以用来访问本类的属性、方法、构造器
2)this用于区分当前类的属性和局部变量
3)访问成员方法的语法：this.方法名（参数列表）;
4)访问构造器语法:this(参数列表)；注意只能在构造器中使用(即只能在构造器中访问另外一个构造器，必须放在第一条语句)
5)this不能在类定义的外部使用，只能在类方法的方法中使用。
- IDEA介绍
1)IDEA全称Intelli IDEA
2)在业界被公认为最好的Java开发工具
3）IDEA是JetBrains公司的产品，总部位于捷克的首都布拉格
4)除了支持Java开发，还支持HTML,CSS,PHP,MYSQL,Python等
- Eclipse介绍
1)Eclipse是一个开放源代码的、基于Java的可扩展开发平台
2)最初是由IBM公司耗资3000万美金开发的下一代IDE开发环境
3)2001年11月贡献给开源社区
4)Eclipse是目前最优秀的Java开发IDE之一
1)官网： https://www.jetbrains.com/
2）IDEA工作界面
-
IDEA常用快捷键
1.删除当前行，默认是ctrl + Y 自己配置ctrl + d
2.复制当前行，自己配置ctrl + alt + 向下光标
3.补全代码 alt + /
4.添加注释和取消注释ctrl + /【第一次是添加注释，第二次是取消注释】
5.导入该行需要的类 先配置auto import，然后使用alt + enter即可
6.快速格式化代码ctrl + alt + L
7.快速运行程序 自己定义alt + R
8.生成构造方法等alt + insert[提高开发效率]
9.查看一个类的层级关系ctrl + H [学习继承后,非常有用]
10.将光标放在一个方法上，输入ctrl + B,可以选择定位到方法[学继承后，非常有用]
11.自动的分配变量名，通过在后面.var -
模板/自定义模板
-
包的三大作用
1.区分相同名字的类
2.当类很多时，可以很好地管理[看JavaAPI文档]
3.控制访问范围 -
包基本语法
package com.hspedu
说明：
1.package关键字，表示打包
2.com.hspedu:表示包名 -
包的本质分析(原理)
包的本质 实际上就是创建不同的文件夹/目录来保存类文件
-
包的命名
√命名规则：
只能包含数字、字母、下划线、小圆点，但不能用数字开头，不能是关键字或保留字
demo.class.exec1 //错误class是关键字
demo.12a //错误12a是以数字开头
demo.ab12.oa //对
√命名规范
一般是小写字母+小圆点一般是
com.公司名.项目名.业务模块名
比如：com.hspedu.oa.model;
com.hspedu.oa.controller;
举例：
com.sina.crm.user //用户模块
com.sina.crm.order //订单模块
com.sina.crm.utils //工具类
- 常用的包
一个包下，包含很多的类，java中常见的包有：
java.lang.* //lang包是基本包，默认引入，不需要再引入
java.util.* //util包，系统提供的工具包，工具类，使用Scanner
java.net.* //网络包，网络开发
java.awt.* //是做java的界面开发,GUI
-
如何引入包
语法：import 包;
比如：import java.util.Scanner; //就只是引入一个类Scanner
import java.util.*; //表示将java.util包所有都引入 -
注意事项和使用细节
1.package的作用是声明当前类所在的包，需要放在类的最上面，一个类中最多只有一句package
2.import指令 位置放在package的下面，在类定义前面，可以有多句且没有顺序要求。
- 基本介绍
java提供四种访问控制修饰符号，用于控制方法和属性(成员变量)的访问权限(范围):
1.公开级别：用public修饰，对外公开
2.受保护级别：用protected修饰，对子类和同一个包的类公开
3.默认级别：没有修饰符号，向同一个包的公开
4.私有级别：用private修饰，只有类本身可以访问，不对外公开
- 使用的注意事项
1）修饰符可以用来修饰类中的属性，成员方法以及类
2）只有默认的和public才能修饰类！并且遵循上述访问权限的特点。
3）因为没有学习继承，因此关于在子类中的访问权限，我们讲完子类后，再回头讲解
4）成员方法的访问规则和属性完全一样
- 基本介绍
面向对象编程有三大特征：封装、继承和多态。
-
封装介绍
封装(encapsulation)就是把抽象出的数据[属性]和对数据的 *** 作[方法]封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的 *** 作[方法],才能对数据进行 *** 作。 -
封装的理解和好处
1)隐藏实现细节： 方法<–调用(传入参数…)
2)可以对数据进行验证,保证安全合理 -
封装的实现步骤（三步）
1)将属性进行私有化private [不能直接修改属性]
2)提供一个公共的(public)set方法，用于对属性判断并赋值
public void setXxx(类型 参数名){ //Xxx表示某个属性
//加入数据验证的业务逻辑
属性 = 参数名;
}
3)提供一个公共的(public)get方法，用于获取属性的值
public XX getXxx(){ //权限判断,Xxx某个属性
return xx;
}
实例：
代码：
package com.hspedu.encap;
import java.sql.SQLOutput;
public class Encapsulation01 {
public static void main(String[] args) {
//如果要使用快捷键alt+r,需要先配置主类
//第一次，我们使用鼠标点击形式运算程序，后面就可以用
Person person = new Person();
person.setName("zt");
person.setAge(30);
person.setSalary(30000);
System.out.println(person.info());
//如果我们自己使用构造器指定属性
Person smith = new Person("smith", 2000, 50000);
System.out.println("====smith的信息====");
System.out.println(smith.info());
}
}
/*
那么在java中如何实现这种类似的控制呢？
请大家看一个小程序(com.hspedu.encap: Encapsulation01.java),
不能随便查看人的工龄，工资等隐私，并对设置的年龄进行合理的验证。年龄合理就设置，否则给默认
年龄，必须在1-120，年龄，工资不能直接查看，name的长度在2-6字符之间
*/
class Person{
public String name; //名字公开
private int age; //age私有化
private double salary; //..
//构造器 alt+insert
public Person() {
}
//有三个属性的构造器
public Person(String name, int age, double salary) {
// this.name = name;
// this.age = age;
// this.salary = salary;
//我们可以将set方法写在构造器中，这样仍然可以验证
setName(name);
setAge(age);
setSalary(salary);
}
//自己写setXxx和getXxx太慢，我们可以使用快捷键
//然后根据要求来完善我们的代码.
public String getName() {
return name;
}
public void setName(String name) {
//加入对数据的校验,相当于增加了业务逻辑
if(name.length() >= 2 && name.length() <= 6){
this.name = name;
}else{
System.out.println("名字的长度不对，需要(2-6)个字符，默认名字");
this.name = "无名人";
}
}
public int getAge() {
return age;
}
public void setAge(int age) {
//判断
if(age >= 1 && age <= 120){
this.age = age;
}else{
System.out.println("你设置的年龄不对，需要在1-120，给默认年龄18");
this.age = 18; //给一个默认年龄
}
}
public double getSalary() {
//可以这里增加对当前对象的权限判断
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
//写一个方法，返回属性信息
public String info(){
return "信息为 name=" + name + " age=" + age + " 薪水=" + salary;
}
}
结果：
-
为什么需要继承
两个类的属性和方法有很多是相同的==>继承(代码复用性~) -
继承基本介绍和示意图
继承可以解决代码复用，让我们的编程更加靠近人类思维。当多个类存在相同的属性(变量)和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends来声明继承父类即可。
-
继承的基本语法
class 子类 extends 父类{
}
1）子类就会自动拥有父类定义的属性和方法
2)父类又叫超类，基类。
3)子类又叫派生类。 -
继承给编程带来的便利
1)代码的复用性提高了
2)代码的扩展性和维护性提高了 -
继承的深入讨论/细节问题
1.子类继承了所有的属性和方法，但是私有属性和方法不能在子类直接访问,要通过公共的方法去访问
2.子类必须调用父类的构造器，完成父类的初始化
3.当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过。
4.如果希望指定去调用父类的某个构造器，则显示的调用一下：super(参数列表)
5.super在使用时，必须放在构造器第一行
6.super()和this()都只能放在构造器第一行，因此这两个方法不能共存在一个构造器
7.java所有类都是Object类的子类，Object是所有类的基类
8.父类构造器的调用不限于直接父类！将一直往上追溯直到Object类(顶级父类)
9.子类最多只能继承一个父类(指直接继承),即java中是单继承机制。
如何让A类继承B类和C类?【A继承B, B继承C】
10.不能滥用继承，子类和父类之间必须满足is - a的逻辑关系
Person is a Music?
Music extends Person//不合理
Cat is an Animal?
Cat extends Animal //合理 -
继承的本质分析(重要)
当子类继承父类，创建子类对象时，内存中到底发生了什么？当子类对象创建好后，建立查找的关系。
实例：
package com.hspedu.extend_;
/**
* 讲解继承的本质
*/
public class ExtendsTheory {
public static void main(String[] args) {
Son son = new Son(); //内存的布局
//?-> 这时请大家注意，要按照查找关系来返回信息
//(1) 首先看子类是否有该属性
//(2) 如果子类有这个属性，并且可以访问，则返回信息
//(3) 如果子类没有这个属性，就看父类有没有这个属性(如果父类有该属性，并且可以访问，就返回信息...)
//(4) 如果父类没有就按照(3)的规则，继续找上级父类,直到Object...
System.out.println(son.name); //返回就是大头儿子
//System.out.println(son.age); //返回的就是39
System.out.println(son.getAge()); //返回的就是39
System.out.println(son.hobby); //返回的就是旅游
}
}
class GrandPa{ //爷类
String name = "大头爷爷";
String hobby = "旅游";
}
class Father extends GrandPa{ //父类
String name = "大头爸爸";
private int age = 39;
public int getAge() {
return age;
}
}
class Son extends Father{ //子类
String name = "大头儿子";
}
输出结果：
√子类创建的内存布局
-
基本介绍
super代表父类的引用，用于访问父类的属性、方法、构造器 -
基本语法
1.访问父类的属性，但不能访问父类的private属性
super.属性名
2.访问父类的方法，不能访问父类的private方法
super.方法名(参数列表);
3.访问父类的构造器
super(参数列表)；只能放在构造器的第一句，只能出现一句！ -
super给编程带来的便利/细节
1.调用父类的构造器的好处(分工明确，父类属性由父类初始化，子类的属性由子类初始化)
2.当子类中有和父类中的成员(属性和方法)重名时，为了访问父类的成员，必须通过super。如果没有重名,使用super、this、直接访问是一样的效果！
3.super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员;如果多个基类(上级类)中都有同名的成员，使用super访问遵循就近原则。A->B->C，当然也需要遵守访问权限的相关规则 -
super和this的比较
-
基本介绍
简单的说：方法覆盖(重写)就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的那个方法 -
注意事项和使用细节
方法重写也叫方法覆盖，需要满足下面的条件
1.子类的方法的参数，方法名称,要和父类方法的参数，方法名称完全一样。
2.子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类
比如父类返回类型是Object，子类方法返回类型是String
3.子类方法不能缩小父类方法的访问权限 -
重写和重载比较
- 多态基本介绍
方法或对象具有多种形态。是面对对象的第三大特征，多态是建立在封装和继承基础之上的。 - 多态的具体体现
1.方法的多态
重写和重载就体现多态
2.对象的多态（核心， 困难， 重点）
重要的几句话：
(1)一个对象的编译类型和运行类型可以不一致
(2)编译类型在定义对象时，就确定了，不能改变
(3)运行类型是可以变化的
(4)编译类型看定义时 = 号的左边，运行类型看 = 号的右边
实例：
Animal animal = new Dog(); [animal编译类型是Animal，运行类型Dog]
animal = new Cat(); [animal的运行类型变成了Cat, 编译类型仍然是Animal]
- 多态注意事项和细节讨论
√多态的前提是：两个对象(类)存在继承关系
√多态的向上转型
1)本质：父类的引用指向了子类的对象
2)语法:父类类型 引用名 = new 子类类型();
3)特点：编译类型看左边，运行类型看右边。
√向上转型调用方法的规则如下：
(1)可以调用父类中的所有成员(需遵守访问权限)
(2)不能调用子类中特有成员
(3)因为在编译阶段，能调用哪些成员，是由编译类型来决定的
(4)最终运行效果看子类(运行类型)的具体实现，即调用方法时，按照从子类(运行类型)开始查找方法
，然后调用，规则和前面我们讲的方法调用规则一致
√多态的向下转型
1)语法：子类类型 引用名 = (子类类型) 父类引用
2)只能强转父类的引用，不能强转父类的对象
3)要求父类的引用必须指向的是当前目标类型的对象
4)当向下转型后，可以调用子类类型中所有的成员
√属性没有重写之说！属性的值看编译类型
√instanceOf比较 *** 作符，用于判断对象的运行类型是否为XX类型或XX类型的子类型
-
java的动态绑定机制(非常非常重要)
1.当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定
2.当调用对象属性时,没有动态绑定机制,哪里声明，哪里使用 -
多态的应用
1)多态数组
数组的定义类型为父类类型，里面保存的实际元素类型为子类类型
2）多态参数
方法定义的形参类型为父类类型，实参类型允许为子类类型
-
equals方法
==和equals的对比
==是一个比较运算符
1.==:既可以判断基本类型，又可以判断引用类型
2.==:如果判断类型，判断的是值是否相等
3.==:如果判断引用类型，判断的是地址是否相等，即判定是不是同一对象
4.equals:是Object类中的方法,只能判断引用类型
5.默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。 -
hashCode方法
1）提高具有哈希结构的容器的效率！
2)两个引用,如果指向的是同一个对象，则哈希值肯定是一样的！
3)两个引用，如果指向的是不同对象，则哈希值是不一样的
4)哈希值主要根据地址号来的！不能完全将哈希值等价于地址。
5.后面在集合，中hashCode如果需要的话，也会重写 -
toString方法
√基本介绍
默认返回：全类名+@+哈希值的十六进制，子类往往重写toString方法，用于返回对象的属性信息
√重写toSring方法，打印对象或拼接对象时，都会自动调用该对象的toString形式(IDEA中可用快捷键创建)
√当直接输出一个对象时,toString方法会被默认的调用
比如
System.out.println(monster); //就会默认调用monster.toString()
- finalize方法
1.当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法，做一些释放资源的 *** 作
2.什么时候被回收：当某个对象没有任何引用时，则jvm就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finalize方法。
3.垃圾回收机制的调用，是由系统来决定(即有自己的GC算法)，也可以通过System.gc()主动触发垃圾回收机制
第7章 2022年4月26日-2022年5月2日
第8章 2022年5月2日-2022年
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）