面向对象编程三大特征:封装、继承、多态

封装、继承、多态

1. 封装

1.1 介绍

        封装(encapsulation)就是把抽象出的数据  [属性] 和对数据的操作  [方法]  封装在一起,数据被保护在内部,程序的其它部分只有通过被授权的操作 [方法] ,才能对数据进行操作。

1.2 封装的理解和好处

1) 隐藏实现细节:方法(连接数据库)<--调用(传入参数..)
2) 可以对数据进行验证,保证安全合理
                Person {name, age}
                Person p = new Person();
                p.name = "jack" ;
                p.age = 1200;

1.3 封装的实现步骤 (三步)

1) 将属性进行私有化private【不能直接修改属性】
2) 提供一个公共的(public) set 方法,用于对属性判断并赋值
        public void setXxx (类型参数名)0/Xx表示某个属性
                //加入数据验证的业务逻辑
                属性 = 参数名;
        }
3) 提供一个公共的(public)get方法,用于获取属性的值
        public 数据类型 getXxx() { //权限判断,Xx某个属性
                return xx;
        }

案例练习:
​​​​
创建程序,在其中定义两个类: Account和AccountTest类 体会Java的封装性。
1. Account类要求具有属性: 姓名(长度为2位3位或4位)、余额(必须>20)、密码(必须是六位),如果不满足,则给出提示信息,并给默认值(程序员自己定)
2. 通过setXxx的方法给Account的属性赋值。
3. 在AccountTest中测试

package com.zakedu.encap;/***创建程序,在其中定义两个类:Account和AccountTest类体会Java的封装性。
*Account类要求具有属性:姓名(长度为2位3位或4位)、余额(必须>20)、
*密码(必须是六位),如果不满足,则给出提示信息,并给默认值(程序员自己定)*通过setXxx的方法给Account的属性赋值。
*在AccountTest中测试 
*/public class Account {//为了封装,将3个属性设置为privateprivate String name;private double balance;private String pwd;//提供两个构造器
public Account() {}public Account(String name, double balance, String pwd) {this.setName(name);this.setBalance(balance);this.setPwd(pwd);}public String getName() {return name;}//姓名(长度为2位3位或4位)
public void setName(String name) {if (name.length() >= 2 && name.length() <= 4) {this.name = name;} else {
System.out.println("姓名要求(长度为 2 位 3 位或4位),默认值 无名");this.name = "无名";}}public double getBalance() {return balance;}//余额(必须>20)public void setBalance(double balance) {if (balance > 20) {this.balance = balance;} else {System.out.println("余额(必须>20) 默认为 0");} }public String getPwd() {return pwd;}//密码(必须是六位)
public void setPwd(String pwd) {if (pwd.length() == 6) {this.pwd = pwd;
}else{System.out.println("密码(必须是六位)默认密码为000000");this.pwd="000000";}}//显示账号信息
public void showInfo(){//可以增加权限的校验
System.out.println("账号信息name="+name+"余额="+balance+"密码"+pwd);// if(){// System.out.println("账号信息name="+name+"余额="+balance+"密码");// }else{// System.out.println("你无权查看...");// }
} }package com.zakedu.encap;public class TestAccount{public static void main(String[]args){//创建AccountAccount account =new Account();account.setName("jack");account.setBalance(60);account.setPwd("123456");account.showInfo();} }

2. 继承

2.1 继承基本介绍

        继承可以解决代码复用,让我们的编程更加靠近人类思维.当多个类存在相同的属性(变量)和方法时,可以从这些类中 抽象出父类,在父类中定义这些相同的属性和方法,所有的子类不需要重新定义这些属性和方法,只需要通过extends来声明继承父类即可。

2.2 继承的基本语法

继承给编程带来的便利:
        1) 代码的复用性提高了         2) 代码的扩展性和维护性提高了

2.3 继承的细节问题

1) 子类继承了所有的属性和方法,非私有的属性和方法可以在子类直接访问,但是私有属性和方法不能在子类直接访 问,要通过父类提供公共的方法去访问
2) 子类必须调用父类的构造器,完成父类的初始化
3) 当创建子类对象时,不管使用子类的哪个构造器,默认情况下总会去调用父类的无参构造器,如果父类没有提供无 参构造器,则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作,否则,编译不会通过。
4) 如果希望指定去调用父类的某个构造器,则显式的调用一下:super(参数列表)
5) super在使用时,必须放在构造器第一行 (super只能在构造器中使用)
6) super()和this()都只能放在构造器第一行,因此这两个方法不能共存在一个构造器
7) java所有类都是Object类的子类,Object是所有类的基类.
8) 父类构造器的调用不限于直接父类!将一直往上追溯直到Object类(顶级父类)
9) 子类最多只能继承一个父类(指直接继承),即java中是单继承机制。
10) 不能滥用继承,子类和父类之间必须满足is-a的逻辑关系

2.4 继承的本质分析:

案例:

 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());//返回的就是 39System.out.println(son.hobby);//返回的就是旅游
}}class GrandPa { //爷类
String name = "大头爷爷";
Stringhobby="旅游";}classFatherextendsGrandPa{//父类
Stringname="大头爸爸";privateintage=39;publicintgetAge(){returnage;} }classSonextendsFather{//子类
Stringname="大头儿子";}

3. super关键字

3.1 基本介绍

super代表父类的引用,用于访问父类的属性、方法、构造器

3.2 基本语法

1. 访问父类的属性,但不能访问父类的private属性
        super . 属性名;
2. 访问父类的方法,不能访问父类的private方法
        super . 方法名(参数列表);
3. 访问父类的构造器:
        super(参数列表) ;  // 只能放在构造器的第一句,只能出现一句!

3.3 super 给编程带来的便利

1. 调用父类的构造器的好处 (分工明确,父类属性由父类初始化,子类的属性由子类初始化)
2. 当子类中有和父类中的成员 (属性和方法)重名时,为了访问父类的成员,必须通过super。如果没有重名,使用super、this、直接访问是一样的效果!
3. super的访问不限于直接父类,如果爷爷类和本类中有同名的成员,也可以使用super去访问爷爷类的成员; 如果多个基类(上级类)中都有同名的成员,使用super访问遵循就近原则。A->B->C,当然也需要遵守访问权限的相关规则

3.4 super 和 this 的比较

4. 方法重写/覆盖

4.1 基本介绍

        简单的说: 方法覆盖(重写)就是子类有一个方法,和父类的某个方法的名称、返回类型、参数一样,那么我们就说子类的这个方法覆盖了父类的方法

4.2 注意事项

方法重写也叫方法覆盖,需要满足下面的条件:

1. 子类的方法的 形参列表,方法名称, 要和父类方法的 形参列表,方法名称 完全一样。
2. 子类方法的返回类型和父类方法返回类型一样,或者是父类返回类型的子类
        比如 父类返回类型是Object,子类方法返回类型是String
        public object getInfo(){ }       与          public String getInfo(){ }
3. 子类方法不能缩小父类方法的访问权限
        public > protected >默认>private
        void sayok(){  }                public void sayok(){ }

重写和重载比较:

5. 多态

5.1 多[多种]态[状态]基本介绍

方法或对象具有多种形态。是面向对象的第三大特征,多态是建立在封装和继承基础之上的。

5.2 多态的具体体现

5.2.1 方法的多态

重写和重载就体现多态
案例:

publicclassPloyMethod{
publicstaticvoidmain(String[]args){//方法重载体现多态
Aa=newA();//这里我们传入不同的参数,就会调用不同sum方法,就体现多态
System.out.println(a.sum(10,20));System.out.println(a.sum(10,20,30));//方法重写体现多态
Bb=newB();a.say();b.say();
}}
classB{//父类
publicvoidsay(){System.out.println("Bsay()方法被调用...");} }
classAextendsB{//子类
publicintsum(intn1,intn2){//和下面sum构成重载
returnn1+n2;}publicintsum(intn1,intn2,intn3){returnn1+n2+n3;}publicvoidsay(){System.out.println("Asay()方法被调用...");}}

5.2.2 对象的多态(核心,困难,重点)

(1) 一个对象的编译类型和运行类型可以不一致
(2) 编译类型在定义对象时,就确定了,不能改变
(3) 运行类型是可以变化的.
(4) 编译类型看定义时 =号的左边,运行类型看 =号的右边
案例:

package com.zakedu.poly_.objectpoly_;
public class Animal{public void cry(){System.out.println("Animalcry()动物在叫....");}}package com.zakedu.poly_.objectpoly_;public class Cat extends Animal{public void cry(){System.out.println("Catcry()小猫喵喵叫...");}}package com.zakedu.poly_.objectpoly_;public class Dog extends Animal{public void cry(){System.out.println("Dogcry()小狗汪汪叫...");}}packagecom.zakedu.poly_.objectpoly_;public class PolyObject{public static void main(String[]args){//体验对象多态特点
//animal编译类型就是Animal,运行类型DogAnimal animal = newDog();//因为运行时,执行到改行时,animal运行类型是Dog,所以cry就是Dog的cryanimal.cry();//小狗汪汪叫
//animal编译类型Animal,运行类型就是Catanimal = new Cat();animal.cry();//小猫喵喵叫
}}

5.3 多态注意事项

多态的前提是:两个对象(类)存在继承关系
多态的向上转型:

多态向下转型:

packagecom.zakedu.poly_.detail_;
public class Animal{String name="动物";intage=10;public void sleep(){System.out.println("睡");}public void run(){System.out.println("跑");
}public void eat(){System.out.println("吃");}public void show(){System.out.println("hello,你好");}}package com.zakedu.poly_.detail_;public class Cat extends Animal {public void eat(){//方法重写
System.out.println("猫吃鱼");}public void catchMouse(){//Cat 特有方法
System.out.println("猫抓老鼠");} }package com.zakedu.poly_.detail_;public class Dog extends Animal {//Dog 是 Animal 的子类
}package com.zakedu.poly_.detail_;public class PolyDetail {
public static void main(String[] args) {//向上转型: 父类的引用指向了子类的对象
//语法:父类类型引用名 =new 子类类型();Animal animal = new Cat();Object obj = new Cat();//可以吗? 可以 Object 也是 Cat 的父类
//向上转型调用方法的规则如下://(1)可以调用父类中的所有成员(需遵守访问权限)//(2)但是不能调用子类的特有的成员
//(#)因为在编译阶段,能调用哪些成员,是由编译类型来决定的
//animal.catchMouse();错误
//(4)最终运行效果看子类(运行类型)的具体实现, 即调用方法时,按照从子类(运行类型)开始查找方法
//,然后调用,规则我前面我们讲的方法调用规则一致。
animal.eat();//猫吃鱼..animal.run();//跑
animal.show();//hello,你好
animal.sleep();//睡//可以调用Cat的 catchMouse方法
//多态的向下转型
//老师希望,可以调用Cat的 catchMouse方法
//(1)语法:子类类型 引用名 =(子类类型)父类引用;//问一个问题?cat 的编译类型 Cat,运行类型是 CatCat cat = (Cat) animal;cat.catchMouse();//猫抓老鼠
//(2)要求父类的引用必须指向的是当前目标类型的对象
Dog dog=(Dog)animal;//可以吗?
System.out.println("ok~~");} }

属性没有重写之说!属性的值看编译类型:

 packagecom.zakedu.poly_.detail_;public class PolyDetail02{public static void main(String[]args){//属性没有重写之说!属性的值看编译类型
Base base = new Sub();//向上转型
System.out.println(base.count);//?看编译类型10Sub sub = new Sub();System.out.println(sub.count);//? 20} }class Base{//父类
int count=10;//属性
}class Sub extends Base{//子类
int count=20;//属性
}

instanceOf 比较操作符,用于判断对象的运行类型是否为XX类型或XX类型的子类型:

package com.zakedu.poly_.detail_;public class PolyDetail03 {public static void main(String[] args) {BB bb = new BB();System.out.println(bb instanceof BB);// trueSystem.out.println(bb instanceof AA);// true//aa 编译类型 AA, 运行类型是BB//BB 是AA子类
AA aa = new BB();System.out.println(aa instanceof AA);System.out.println(aa instanceof BB);Object obj = new Object();System.out.println(obj instanceof AA);//falseString str = "hello";//System.out.println(str instanceof AA);System.out.println(str instanceof Object);//true} }class AA{} //父类
class BB extends AA{}//子类

5.4 java 的动态绑定机制(非常非常重要.)

5.5 多态的应用

5.5.1 多态数组:

数组的定义类型为父类类型,里面保存的实际元素类型为子类类型

应用实例:
        现有一个继承结构如下:要求创建1个Person对象、2个Student对象和2个Teacher对象,统一放在数组 中,并调用每个对象say方法.
        应用实例升级:如何调用子类特有的方法,比如 Teacher有一个teach,Student有一个study 怎么调用?
代码:

 package com.zakedu.poly_.polyarr_;public class Person{//父类private String name;private int age;public Person(Stringname,intage){this.name=name;this.age=age;}public String getName(){return name;}public voidsetName(String name){this.name=name;}public int getAge(){return age;}public void setAge(intage){this.age=age;}public String say(){//返回名字和年龄
return name+"\t"+age;} }packagecom.zakedu.poly_.polyarr_;public class Student extends Person{private double score;public Student(String name,int age,double score){super(name, age);this.score = score;}public double getScore() {return score;}public void setScore(double score) {this.score = score;}//重写父类say@Overridepublic String say() {return "学生 " + super.say() + " score=" + score;}//特有的方法
public void study() {System.out.println("学生 " + getName() + " 正在学 java...");} }package com.zakedu.poly_.polyarr_;public class Teacher extends Person {private double salary;public Teacher(String name, int age, double salary) {super(name, age);this.salary = salary;}public double getSalary() {return salary;}public void setSalary(double salary) {this.salary = salary;}//写重写父类的say方法
@Overridepublic String say() {return "老师 " + super.say() + " salary=" + salary;}//特有方法
public void teach() {System.out.println("老师 " + getName() + " 正在讲 java 课程...");} }
package com.zakedu.poly_.polyarr_;public class PloyArray {public static void main(String[] args) {//应用实例:现有一个继承结构如下:要求创建1个Person对象、
// 2 个Student 对象和2个Teacher 对象, 统一放在数组中,并调用每个对象say方法
Person[] persons = new Person[5];persons[0] = new Person("jack", 20);persons[1] = new Student("mary", 18, 100);persons[2] = new Student("smith", 19, 30.1);persons[3] = new Teacher("scott", 30, 20000);persons[4] = new Teacher("king", 50, 25000);//循环遍历多态数组,调用sayfor (int i = 0; i < persons.length; i++) {System.out.println(persons[i].say());//动态绑定机制
//老师提示:person[i] 编译类型是 Person,运行类型是是根据实际情况有JVM来判断
//这里大家聪明. 使用 类型判断 + 向下转型.if(persons[i] instanceof Student) {//判断 person[i] 的运行类型是不是 StudentStudent student = (Student)persons[i];//向下转型student.study();//小伙伴也可以使用一条语句 ((Student)persons[i]).study();} else if(persons[i] instanceof Teacher) {Teacher teacher = (Teacher)persons[i];teacher.teach();
} else if(persons[i] instanceof Person){//System.out.println("你的类型有误, 请自己检查...");} else {System.out.println("你的类型有误, 请自己检查...");} } } }

5.5.2 多态参数

代码:

 package com.zakedu.poly_.polyparameter_;public class Employee {private String name;private double salary;public Employee(String name, double salary) {this.name = name;this.salary = salary;}//得到年工资的方法
public double getAnnual() {return 12 * salary;}public String getName() {return name;}public void setName(String name) {this.name = name;}public double getSalary() {return salary;}public void setSalary(double salary) {this.salary = salary;
} }package com.zakedu.poly_.polyparameter_;public class Manager extends Employee{private double bonus;public Manager(String name, double salary, double bonus) {super(name, salary);this.bonus = bonus;}public double getBonus() {return bonus;}public void setBonus(double bonus) {this.bonus = bonus;}public void manage() {System.out.println("经理 " + getName() + " is managing");}//重写获取年薪方法
@Override
public double getAnnual(){returnsuper.getAnnual()+bonus;} }packagecom.zakedu.poly_.polyparameter_;public class Worker extends Employee{public Worker(Stringname,doublesalary){super(name,salary);}public void work(){System.out.println("普通员工"+getName()+"isworking");}@Overridepublic double getAnnual(){//因为普通员工没有其它收入,则直接调用父类方法
return super.getAnnual();} }packagecom.zakedu.poly_.polyparameter_;public class PloyParameter{public static void main(String[]args){Worker tom=new Worker("tom",2500);
Manager milan = new Manager("milan", 5000, 200000);PloyParameter ployParameter = new PloyParameter();ployParameter.showEmpAnnual(tom);ployParameter.showEmpAnnual(milan);ployParameter.testWork(tom);ployParameter.testWork(milan);}//showEmpAnnual(Employee e)//实现获取任何员工对象的年工资,并在main方法中调用该方法 [e.getAnnual()]public void showEmpAnnual(Employee e) {System.out.println(e.getAnnual());//动态绑定机制.}public void testWork(Employee e) {if(e instanceof Worker) {((Worker) e).work();//有向下转型操作
} else if(e instanceof Manager) {} else {//添加一个方法,testWork,如果是普通员工,则调用work方法,如果是经理,则调用manage方法
((Manager) e).manage();//有向下转型操作
System.out.println("不做处理...");} } }

6. Object类详解

6.1 equals方法

== 和 equals的对比 (面试题):
==是一个比较运算符
1. ==:既可以判断基本类型,又可以判断引用类型;
2. ==:如果判断基本类型,判断的是值是否相等。示例: int i=10; double d=10.0;
3. ==:如果判断引用类型,判断的是地址是否相等,即判定是不是同一个对象;
4. equals:是Object类中的方法,只能判断引用类型;
5. 默认判断的是地址是否相等,子类中往往重写该方法,用于判断内容是否相等。比如
lnteger,String【看看String和Integer的equals源代码】。
代码:

publicclassEquals01{
public static void main(String[]args){A a = new A();A b=a;A c=b;System.out.println(a==c);//trueSystem.out.println(b==c);//trueB bObj =a;System.out.println(bObj==c);//trueint num1 =10double num2 = 10.0;System.out.println(num1 == num2);//基本数据类型,判断值是否相等
//equals 方法,源码怎么查看.//把光标放在equals 方法,直接输入ctrl+b//如果你使用不了. 自己配置. 即可使用./*//带大家看看Jdk的源码 String类的 equals方法
//把 Object 的 equals 方法重写了,变成了比较两个字符串值是否相同
public boolean equals(Object anObject) {if (this == anObject) {//如果是同一个对象
return true;//返回 true}if (anObject instanceof String) {//判断类型
String anotherString = (String)anObject;//向下转型
int n = value.length;if (n == anotherString.value.length) {//如果长度相同
char v1[] = value;int i = 0;char v2[] = anotherString.value;while (n-- != 0) {//然后一个一个的比较字符
if (v1[i] != v2[i])return false;i++;}
return true;//如果两个字符串的所有字符都相等,则返回true}}return false;//如果比较的不是字符串,则直接返回false}*/"hello".equals("abc");//看看Object 类的 equals 是
/*//即 Object 的 equals 方法默认就是比较对象地址是否相同
//也就是判断两个对象是不是同一个对象.public boolean equals(Object obj) {return (this == obj);}*//*//从源码可以看到 Integer 也重写了Object的equals方法,//变成了判断两个值是否相同
public boolean equals(Object obj) {if (obj instanceof Integer) {return value == ((Integer)obj).intValue()
}return false;}*/Integer integer1 = new Integer(1000);Integer integer2 = new Integer(1000);System.out.println(integer1 == integer2);//falseSystem.out.println(integer1.equals(integer2));//trueString str1 = new String("hspedu");String str2 = new String("hspedu");System.out.println(str1 == str2);//falseSystem.out.println(str1.equals(str2));//true}}class B {}class Aextends B {}

6.2 如何重写equals方法

应用实例: 判断两个Person对象的内容是否相等,如果两个Person对象的各个属性值都一样,则返回true,反之false。

 public class EqualsExercise01 {public static void main(String[] args) {Person person1 = new Person("jack", 10, '男');Person person2 = new Person("jack", 20, '男');System.out.println(person1.equals(person2));//假
}}//判断两个Person对象的内容是否相等,
//如果两个Person对象的各个属性值都一样,则返回true,反之falseclass Person{ //extends Objectprivate String name;private int age;private char gender;//重写Object 的 equals 方法
public boolean equals(Object obj) {if(this == obj) {//判断如果比较的两个对象是同一个对象,则直接返回truereturn true;}//类型判断
if(obj instanceof Person) {//是 Person,我们才比较
//进行 向下转型, 因为我需要得到obj的 各个属性
Person p = (Person)obj;return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender;}//如果不是Person ,则直接返回falsereturn false;}public Person(String name, int age, char gender) {this.name = name;this.age = age;this.gender = gender;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;
}public void setAge(intage){this.age=age;}public char getGender(){return gender;}public void setGender(chargender){this.gender=gender;} }

6.3 hashCode 方法

6个小结:
1) 提高具有哈希结构的容器的效率!
2) 两个引用,如果指向的是同一个对象,则哈希值肯定是一样的!
3) 两个引用,如果指向的是不同对象,则哈希值是不一样的
4) 哈希值主要根据地址号来的!, 不能完全将哈希值等价于地址。
5)案例演示[HashCode_.java]:obj.hashCode() [测试:Aobj1=newA();Aobj2=newA();Aobj3=obj1]
代码:

public class HashCode_{public static void main(String[]args){AA aa= new AA();AA aa2= new AA();AA aa3=aa;System.out.println("aa.hashCode()="+aa.hashCode());System.out.println("aa2.hashCode()="+aa2.hashCode());System.out.println("aa3.hashCode()="+aa3.hashCode());} }class AA{}

6.4 toString方法

1. 基本介绍:
默认返回:全类名+@+哈希值的十六进制,【查看Object的toString方法】 子类往往重写toString方法,用于返回对象的属性信息
2.  重写toString方法,打印对象或拼接对象时,都会自动调用该对象的toString形式
3.  当直接输出一个对象时,toString 方法会被默认的调用, 比如 System.out.println(monster); 就会默认调用 monster.toString()
代码:

 public class ToString_ {public static void main(String[] args) {/*Object 的 toString() 源码
(1)getClass().getName() 类的全类名(包名+类名 )(2)Integer.toHexString(hashCode()) 将对象的 hashCode 值转成 16 进制字符串
public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());}*/Monster monster = new Monster("小妖怪", "巡山的", 1000);System.out.println(monster.toString() + " hashcode=" + monster.hashCode());System.out.println("==当直接输出一个对象时,toString 方法会被默认的调用==");System.out.println(monster); //等价 monster.toString()
} }class Monster {private String name;private String job;private double sal;public Monster(String name, String job, double sal) {this.name = name;this.job = job;this.sal = sal;}//重写toString 方法, 输出对象的属性
//使用快捷键即可 alt+insert-> toString@Overridereturn "Monster{" +"name='" + name + '\' +public String toString() { //重写后,一般是把对象的属性值输出,当然程序员也可以自己定制
", job='" + job + '\' +", sal=" + sal +'}';}@Override
protectedvoidfinalize()throwsThrowable{System.out.println("fin..");} }

6.5 finalize方法

1) 当对象被回收时,系统自动调用该对象的finalize方法。子类可以重写该方法,做一些释放资源的操作
2) 什么时候被回收:当某个对象没有任何引用时,则jvm就认为这个对象是一个垃圾对象,就会使用垃圾回收机制来 销毁该对象,在销毁该对象前,会先调用finalize方法。
3) 垃圾回收机制的调用,是由系统来决定(即有自己的GC算法),也可以通过System.gc()主动触发垃圾回收机制,测 试:Car[name]
提示:我们在实际开发中,几乎不会运用finalize,所以更多就是为了应付面试.
代码:
 

//演示Finalize的用法
public class Finalize_{public static void main(String[]args){Car bmw =new Car("宝马");//这时car对象就是一个垃圾,垃圾回收器就会回收(销毁)对象,在销毁对象前,会调用该对象的finalize方法
//,程序员就可以在finalize中,写自己的业务逻辑代码(比如释放资源:数据库连接,或者打开文件..)//,如果程序员不重写finalize,那么就会调用Object类的finalize,即默认处理
//,如果程序员重写了finalize, 就可以实现自己的逻辑bmw =null;System.gc();//主动调用垃圾回收器
System.out.println("程序退出了....");} }class Car {private String name;//属性, 资源。。
public Car(String name) {this.name = name;}//重写finalize@Overrideprotected void finalize() throws Throwable {System.out.println("我们销毁 汽车" + name );System.out.println("释放了某些资源...");} }

7. 断点调试(debug)

7.1 断点调试介绍

1. 断点调试是指在程序的某一行设置一个断点,调试时,程序运行到这一行就会停住,然后你可以一步一步往下调试,调试过程中可以看各个变量当前的值,出错的话,调试到出错的代码行即显示错误,停下。进行分析从而找到这个Bug
2. 断点调试是程序员必须掌握的技能。
3. 断点调试也能帮助我们查看java底层源代码的执行过程,提高程序员的Java水平。

7.2 断点调试的快捷键

F7(跳入) F8(跳过) shift+F8(跳出)F9(resume,执行到下一个断点)
F7:跳入方法内
F8: 逐行执行代码.
shift+F8: 跳出方法

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/pingmian/4952.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

STM32CubeMX+MDK通过I2S接口进行音频输入输出(全双工读写一个DMA回调)续-音质问题解决总结

一、前言 之前进行了STM32CubeMXMDK通过I2S接口进行音频输入输出&#xff08;全双工读写一个DMA回调&#xff09;的研究总结&#xff1a; https://juejin.cn/post/7339016190612881408#heading-34 后续音质问题解决了&#xff0c;目前测试下来48khz的双声道使用效果很好&…

JSON.toJSONString() 输出 “$ref“:“$[0]“问题解决及原因分析

一、背景 在构建一个公共的批处理方法类的时候&#xff0c;在测试输出的时候&#xff0c;打印了" r e f " : " ref":" ref":"[0][0]"的内容&#xff0c;这让我比较疑惑。不由得继续了下去… 二、问题分析 首先&#xff0c;我们需要…

安卓开发Webview RTC 适配

一、场景 在混合开发方式中&#xff0c;项目前端使用了tracking.js 开发了一个人脸识别功能&#xff0c;但是在安卓端无法成功调用摄像头进行视频捕获&#xff0c;在浏览器中可以正常使用该功能。 二、问题分析 之前的音视频文件适配提供给前端的方式&#xff0c;都是通过inp…

web服务的部署及高级优化

搭建web服务器 1.1、配置主机IP以及软件仓库搭建 [rootserver129 ~]# vmset.sh 100 //主机IP配置为172.25.254.100 1.2、查看搭建web服务器所需的软件包 [rootserver100 ~]# dnf search nginx 名称 精准匹配&#xff1a;nginx nginx.x86_64 : A high performance web serve…

头歌实践教学平台:CG7-v2.0-实体消隐

第1关&#xff1a;立方体消隐 一. 任务描述 1. 本关任务 (1) 理解深度缓冲器算法(Z-Buffer)算法; (2) 将triangle函数和main函数中的空白部分补充完整。 2. 输入 (1) 代码将自动输入一个边长为1的obj正方体模型&#xff0c;具体模型如下图&#xff1a; (2) 代码会自动对将…

Kafka Exactly Once 语义实现原理:幂等性与事务消息

01 前言 在现代分布式系统中&#xff0c;确保数据处理的准确性和一致性是至关重要的。Apache Kafka&#xff0c;作为一个广泛使用的流处理平台&#xff0c;提供了强大的消息队列和流处理功能。随着业务需求的增长&#xff0c;Kafka 的事务消息功能应运而生&#xff0c;它允许应…

单链表的经典oj题(1)

前言 这次博客将要以图解的形式&#xff0c;把单链表的经典题目&#xff0c;讲解&#xff0c;绝对是干货&#xff0c;来吧兄弟萌 第一题 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 …

USB HID报告描述符学习

参考资料 HID 报告描述符 (qq.com)https://mp.weixin.qq.com/s?__bizMzU1ODI3MzQ1MA&mid2247485748&idx1&sn112bd8014eb96b03308b3b808549e8d4&chksmfc284ff1cb5fc6e770c2d2ece46c17bf2529901b45a357938978fa62163723556ad497b05c47&cur_album_id3340417…

三、VLAN间路由(三层交换)

VLAN间路由可以通过二层交换机配合路由器来实现&#xff0c;也可以通过三层交换机来实现。 目录 1.单臂路由 2.通过三层交换机实现不同vlan的互访 1.单臂路由 注&#xff1a; 1.三层接口不能正确识别带vlan tag的数据帧 2.所有子接口与主接口共享MAC地址 命令 int g0/0/0.1…

试用了三个Ai音乐工具,我的偶像河图要完蛋了

试了三个生成音乐的ai工具&#xff0c;分别是爆火的suno,后期新秀udio&#xff0c;还有我们国内的天工。 先说感受&#xff0c;suno和天工我觉得稍微靠前&#xff0c;udio可能我的配置风格有问题&#xff0c;啪啪啪连选了好几个风格&#xff0c;生成的东西有点怪。 我随手写了…

语音识别的基本概念

语音识别的基本概念​​​​​​​ ​​​​​​​ 言语是一种复杂的现象。人们很少了解它是如何产生和感知的。天真的想法常常是语音是由单词构成的&#xff0c;而每个单词又由音素组成。不幸的是&#xff0c;现实却大不相同。语音是一个动态过程&#xff0c;没有明确区分的…

linux学习:线程安全(信号量+互斥锁读写锁+条件变量+可重入函数)

目录 信号量 有名信号量 步骤 api 创建、打开一个POSIX有名信号量 对 POSIX 有名信号量进行 P、V 操作 关闭、删除 POSIX 有名信号量 例子 无名信号量 步骤 api 初始化、销毁 POSIX 无名信号量 互斥锁读写锁 例子 两条线程 使用互斥锁来互斥地访问标准输出 在加锁…

1.认识USB协议

目录 前言 在嵌入式场景的具体体现 USB通信协议 总结 前言 在这之前&#xff0c;我们需要认识USB是什么东西&#xff0c;它是一种通信协议&#xff0c;协议只是规定数据的&#xff0c;在物理层面上&#xff0c;它可以有多种表现形式。在我们日常生活中也非常常见&#xff0…

FebHost:什么是挪威.no域名,如何注册?

挪威国家域名介绍 挪威是一个位于北欧的国家&#xff0c;北面和西面是大西洋和北海&#xff0c;东面和南面则与瑞典、芬兰接壤。挪威是一个高度发达的经济体&#xff0c;其政府在经济管理和可持续发展方面也取得了很多成就。挪威的人均GDP在世界范围内排名非常靠前&#xff0c…

【Unity】 使用代码分析(Roslyn Analyzers)实现自动代码审查(Code Review)

索引 Roslyn AnalyzersCode Review自动 Code Review 案例1.public、internal权限的字段建议以大写字母开头。2.private、protected权限的字段建议以下划线小写字母开头。3.不建议直接继承 MonoBehaviour&#xff0c;建议继承至 HTBehaviour。4.不建议使用 Input 判断输入或获取…

命令执行。

命令执行 在该项目的readme中&#xff0c;描述了怎么去调用的flink 通过java原生的runtime来调用flink&#xff0c;下一步就是去看看具体的调用过程了&#xff0c;是否存在可控的参数 找到具体提交命令的类方法CommandRpcClinetAdapterImpl#submitJob() 这里要确定command&am…

C++-6

使用模板类&#xff0c;实现顺序栈。 #include <iostream>using namespace std; template <typename T> class Seqlite {T data[30];int len0; public:void head_inst(T date);void head_dele();void show(); }; template <typename T> …

Phi-3-mini-4k-instruct 的功能测试

Model card 介绍 Phi-3-Mini-4K-Instruct 是一个 3.8B 参数、轻量级、最先进的开放模型&#xff0c;使用 Phi-3 数据集进行训练&#xff0c;其中包括合成数据和经过过滤的公开可用网站数据&#xff0c;重点是 高品质和推理密集的属性。 该型号属于 Phi-3 系列&#xff0c;Mini…

Django框架之ORM操作

一、选择数据库 1、默认数据库 Django默认的数据库是sqlite3数据库 DATABASES {default: {ENGINE: django.db.backends.sqlite3,NAME: BASE_DIR / db.sqlite3,} }2、指定数据库 修改连接到MySQL数据库 DATABASES {default: {ENGINE: django.db.backends.mysql,# 数据库名…

一、安装Redis并运行

Windows安装Redis 1.打开网址下载 下载地址&#xff1a;https://github.com/tporadowski/redis/releases。 Redis 支持 32 位和 64 位。这个需要根据你系统平台的实际情况选择 我选择的是 然后一步步安装 可以参考&#xff1a;https://blog.csdn.net/zbx931197485/article/d…