IDE(集成开发环境)
包
包的三大作用
-
区分相同名字的类
-
当类很多时,可以很好的管理类[看Java API 文档]
-
控制访问范围
包基本语
java
package com.hsppedu;
说明:
1. package 关键字,表示打包
2. com.haspedu:表示包名
包的本质分析(原理)
包的本质就是创建不同的文件夹来保存类文件
示例
java
package com.use;
import com.xiaoqiang.Dog;
public class Test {
public static void main(String[] args) {
Dog dog=new Dog();
System.out.println(dog);
com.xiaoming.Dog dog1=new com.xiaoming.Dog();
}
}
包的命名
命名规则:只能包含数字,字母,下划线,小圆点,但不能数字开头,不能是关键字或保留字
命名规范
一般是小写字母+小圆点
com.公司名.项目名.业务模块名
常用的包
- java.lang.* lang包是基本包,默认引入,不需要再引入
- java.util.* util包系统提供的工具包,工具类,使用Scanner
- java.net.* 网络包,网络开发
- java.awt.*是做Java界面开发GUI
如何引入包
语法:import 包
引入包主要是使用该包下面的类
可以只引入某个包下面的一个类,也可以引入某个包下面所有的类
例如:import java.util.Scanner 和 import java.util.*
注意事项和使用细节
1.package的作用是声明当前类所在的包,需要放在类的最上面,一个类中最多只有语句package
2.import指令,位置放在package的下面,再类定义前面,可以有多句且没有顺序
访问修饰符
基本介绍
java 提供四种访问控制修饰符号,用于控制方法和属性(成员变量)的访问权限(范围):
-
- 公开级别:用public 修饰,对外公开
-
- 受保护级别:用protected修饰,对子类和同一个包中的类公开
-
- 默认级别:没有修饰符号,向同一个包的类公开.
-
- 私有级别:用private修饰,只有类本身可以访问,不对外公开.
四种访问修饰符的访问范围
java
public 公有的 当前工程的任意位置访问
protected 保护的 本类 同包 子类
默认不写 默认的 本类 同包
private 私有的 本类
使用的注意事项
- 1.修饰符可以用来修饰类以及类中的属性,成员方法
- 2.只有默认的和public才可以修饰类
- 3.成员方法的访问规则和属性完全一样
面向对象编程三大特征
面向对象编程有三大特征:封装、继承和多态。
面向对象编程-封装
封装就是把抽象出的数据【属性】和对数据操作【方法】封装在一起,数据被保护在内部,程序的其他部分只有通过授权的操作【方法】,才能对数据进行操作
封装的理解和好处
1.隐藏实现细节,方法(连接数据库) < --调用(传入参数..)
2.可以对数据进行验证,保证安全合理
封装的实现步骤 (三步)
- 1.将属性私有化(不能直接修改属性)
- 2.提供一个公共的set方法,用于对属性判断并赋值(加入数据验证的业务逻辑)
- 3.提供哦那个一个公共的get方法,用于获取属性的值
java
public void setXXX(类型,参数名){
//加入数据验证的业务逻辑
属性=参数名;
}
public 数据类型 getXXX(){
//权限判断
return XX;
}
面向对象编程-继承
继承基本介绍和示意图
继承可以解决代码复用,当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类,在父类中定义这些相同的属性和方法,所有的子类不需要重新定义这些属性和方法,只需要通过extends来声明继承父类
继承的基本语法
java
class 子类 extends 父类{
}
- 1.子类就会自动拥有父类定义的属性和方法
- 2.父类又叫基类,超类
- 3.子类又叫派生类
继承给编程带来的便利
- 1)代码的复用性提高了
- 2)代码的扩展性和维护性提高了
继承的深入讨论/细节问题
- 1)子类继承了所有的属性和方法,非私有的属性和方法可以在子类直接访问,但是私有属性和方法不能在子类直接访 问,要通过父类提供公共的方法去访问
- 2)子类必须调用父类的构造器,完成父类的初始化
- 3)当创建子类对象时,不管使用子类的哪个构造器,默认情况下总会去调用父类的无参构造器,如果父类没有提供无参构造器,则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作,否则,编译不会通过(怎么理解。)
- 4)如果希望指定去调用父类的某个构造器,则显式的调用一下:super(参数列表)
-
- super在使用时,必须放在构造器第一行(super只能在构造器中使用)
-
- super()和this()都只能放在构造器第一行,因此这两个方法不能共存在一个构造器
-
- java所有类都是Object类的子类,Object是所有类的基类.
- 8)父类构造器的调用不限于直接父类!将一直往上追溯直到Object类(顶级父类)
- 9)子类最多只能继承一个父类(指直接继承),即java中是单继承机制。
思考:如何让A类继承B类和C类?【A继承B,B继承C】 - 10)不能滥用继承,子类和父类之间必须满足is-a的逻辑关系
继承的本质分析**(重要)**
java
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 = "大头儿子";
}
按照查找关系返回信息
1.首先查看子类是否有该属性
2.如果子类有这个属性,并且可以访问,则返回信息
3.如果子类没有这个属性。就看父类有没有这个属性(如果父类有该属性,并且可以访问,就返回信息)
4.如果父类没有就继续赵上一级父类,直到Object
super关键字
基本介绍
super代表父类的引用,用于访问父类的属性、方法、构造器
基本语法
- 1.访问父类的属性,单不能访问父类的private属性:super.属性
- 2.访问父类的方法,但不能访问父类发private方法:super.方法
- 3.访问父类的构造器:super(参数列表);
只能放在构造器的第一句,只能出现那一句,只能再构造器中调用,不能与this语句同时使用
使用细节
- 1.调用父类构造器的好处:分工明确,父类的属性由父类初始化,子类的属性由子类初始化
- 2.当子类中有和父类中的成员重名时,未来访问父类的成员,必须通过super,如果没有重名,使用super,this,直接访问都是一样的
- 3.super的访问不限于直接父类,如果爷爷类和奔雷中有同名的成员,有可以用super去访问爷爷类的成员,如果多个基类中都有同名的成员,使用super访问遵循就近原则
super 和 this 的比较
方法重写/覆盖(override)
基本介绍:方法覆盖就是子类有一个方法和父类的莫格方法的名称,返回类,参数一模一样,我们就说子类的中国方法覆盖率父类的方法
需要满足的条件
- 1.子类的方法的参数,方法名称,要和父类方法的参数,方法名称玩去哪一样
- 2.子类方法的返回类型和父类方法的返回类型一样,或者是父类返回类型的子类,比如:父类的返回类型是Object,子类方法的返回类型但是String
- 3.子类方法不能缩小父类方法的访问权限
方法重写和方法重载的区别
面向对象编程-多态
多[多种]态[状态]基本介绍
方法或对象具有多种形态。是面向对象的第三大特征,多态是建立在封装和继承基础之上的。
具体体现
1.方法的多态
- 重写和重载就体现多态
- 重载:通过传入不同的参数调用同名的不同的方法,对于该方法来说就是多种状态的体现
- 重写:根据不同的对象调用同名的不同的方法,对于该方法来说就是多种状态的体现
2.对象的多态
- 一个对象的编译类型和运行类型可以不一致{父类的引用可以指向子类的对象)
- 编译类型在定义对象时就确定了,不能改变
- 运行类型是可以变化的
- 编译类型看定义时=号的左边,运行类型看=号的右边
多态快速入门案例
使用多态的机制来解决主人喂食物的问题
java
package com.hspedu.poly_;
public class Poly01 {
public static void main(String[] args) {
Master tom = new Master("汤姆");
Dog dog = new Dog("大黄~");
Bone bone = new Bone("大棒骨~");
tom.feed(dog, bone);
Cat cat = new Cat("小花猫~");
Fish fish = new Fish("黄花鱼~");
System.out.println("===========-------");
tom.feed(cat, fish);
//添加 给小猪为米饭
Pig pig = new Pig("小花猪");
Rice rice = new Rice("米饭");
System.out.println("===================");
tom.feed(pig, rice);
}
}
java
package com.hspedu.poly_;
public class Animal {
private String name;
public Animal(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
java
package com.hspedu.poly_;
public class Cat extends Animal {
public Cat(String name) {
super(name);
}
}
java
package com.hspedu.poly_;
public class Dog extends Animal {
public Dog(String name) {
super(name);
}
}
java
package com.hspedu.poly_;
public class Pig extends Animal {
public Pig(String name) {
super(name);
}
}
java
package com.hspedu.poly_;
public class Food {
private String name;
public Food(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
java
package com.hspedu.poly_;
public class Bone extends Food {
public Bone(String name) {
super(name);
}
}
java
package com.hspedu.poly_;
public class Fish extends Food {
public Fish(String name) {
super(name);
}
}
java
package com.hspedu.poly_;
public class Rice extends Food {
public Rice(String name) {
super(name);
}
}
java
package com.hspedu.poly_;
public class Master {
private String name;
public Master(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//使用多态机制,可以统一的管理主人喂食的问题
//animal 编译类型是Animal,可以指向(接收) Animal子类的对象
//food 编译类型是Food ,可以指向(接收) Food子类的对象
public void feed(Animal animal, Food food) {
System.out.println("主人 " + name + " 给 " + animal.getName() + " 吃 " + food.getName());
}
//主人给小狗 喂食 骨头
// public void feed(Dog dog, Bone bone) {
// System.out.println("主人 " + name + " 给 " + dog.getName() + " 吃 " + bone.getName());
// }
// //主人给 小猫喂 黄花鱼
// public void feed(Cat cat, Fish fish) {
// System.out.println("主人 " + name + " 给 " + cat.getName() + " 吃 " + fish.getName());
// }
//如果动物很多,食物很多
//===> feed 方法很多,不利于管理和维护
//Pig --> Rice
//Tiger ---> meat ...
//...
}
多态注意事项和细节讨论
多态的前提是:两个对象(类)存在继承关系
多态的向上转型
- 1.本质: 父类引用指向了子类的对象
- 2.语法:父类类型 引用名=new 子类类型()
- 3.特点:编译类型看左边,运行类型看右边
可以调用父类中的所有成员(需要遵守访问权限)
不能调用子类中的特有成员(因为在编译阶段,能调用哪些成员,是由编译类型决定的
最终运行效果看子类的具体实现,运行是关心运行类型,不关心编译类型
调用运行的方法遵循就近原则,先从运行时的子类类型开始查找,未能找到时逐级向父类递增
多态向下转型
- 1.语法:子类类型 引用名=(子类类型)父类引用
- 2.只能强转父类的引用,不能强转父类的对象
- 3.要求父类的引用必须指向的是当前目标类型的对象
- 4.当向下转型后,可以调用子类类型中的所有成员
代码示例
java
package com.hspedu.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方法
//多态的向下转型
//(1)语法:子类类型 引用名 =(子类类型)父类引用;
//问一个问题? cat 的编译类型 Cat,运行类型是 Cat
Cat cat = (Cat) animal;
cat.catchMouse();//猫抓老鼠
//(2)要求父类的引用必须指向的是当前目标类型的对象
Dog dog = (Dog) animal; //可以吗?
System.out.println("ok~~");
}
}
java
package com.hspedu.poly_.detail_;
public class Animal {
String name = "动物";
int age = 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,你好");
}
}
java
package com.hspedu.poly_.detail_;
public class Cat extends Animal {
public void eat(){//方法重写
System.out.println("猫吃鱼");
}
public void catchMouse(){//Cat特有方法
System.out.println("猫抓老鼠");
}
}
java
package com.hspedu.poly_.detail_;
public class Dog extends Animal {//Dog是Animal的子类
}
属性没有重写之说!属性的值看编译类型
java
package com.hspedu.poly_.detail_;
public class PolyDetail02 {
public static void main(String[] args) {
//属性没有重写之说!属性的值看编译类型
Base base = new Sub();//向上转型
System.out.println(base.count);// ? 看编译类型 10
Sub sub = new Sub();
System.out.println(sub.count);//? 20
}
}
class Base { //父类
int count = 10;//属性
}
class Sub extends Base {//子类
int count = 20;//属性
}
instanceOf 比较操作符,用于判断对象的运行类型是否为XX类型或XX类型的子类型
java
package com.hspedu.poly_.detail_;
public class PolyDetail03 {
public static void main(String[] args) {
BB bb = new BB();
System.out.println(bb instanceof BB);// true
System.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);//false
String str = "hello";
//System.out.println(str instanceof AA);
System.out.println(str instanceof Object);//true
}
}
class AA {} //父类
class BB extends AA {}//子类
java 的动态绑定机制(非常非常重要.)
Java 重要特性: 动态绑定机制
- 1.当调用对象方法的时候,该方法会对该对象的内存地址/运行类型进行绑定
- 2.当调用对象属性时,没有动态绑定机制,哪里声明,哪里使用
多态的应用
多态数组
数组的定义类型为父类类型,里面保存的实际元素类型为子类类型
调用各元素的特有方法时,借助instanceOf判断类型后进行向下转型
**应用实例:**现有一个继承结构如下:要求创建1个Person对象、2个Student对象和2个Teacher对象,统一放在数组 中,并调用每个对象
代码
java
package com.hspedu.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);
//循环遍历多态数组,调用say
for (int i = 0; i < persons.length; i++) {
//老师提示: person[i] 编译类型是 Person ,运行类型是是根据实际情况有JVM来判断
System.out.println(persons[i].say());//动态绑定机制
//这里大家聪明. 使用 类型判断 + 向下转型.
if(persons[i] instanceof Student) {//判断person[i] 的运行类型是不是Student
Student 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("你的类型有误, 请自己检查...");
}
}
}
}
java
package com.hspedu.poly_.polyarr_;
public class Person {//父类
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
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 String say() {//返回名字和年龄
return name + "\t" + age;
}
}
java
package com.hspedu.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
@Override
public String say() {
return "学生 " + super.say() + " score=" + score;
}
//特有的方法
public void study() {
System.out.println("学生 " + getName() + " 正在学java...");
}
}
java
package com.hspedu.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方法
@Override
public String say() {
return "老师 " + super.say() + " salary=" + salary;
}
//特有方法
public void teach() {
System.out.println("老师 " + getName() + " 正在讲java课程...");
}
}
多态参数
方法定义的形参类型为父类类型,实参类型允许为子类类型
Object类详解
object类是类层次结构的根类,每个类都使用object作为超类,所有对象(包括数组)都要实现这个类的方法
equals方法
==和equals的对比[面试题]
==是一个比较运算符
- 1.既可以判断基本类型,又可以判断引用类型
- 2.如果判断基本类型:判断的值是否相等
- 3.如果判断引用类型,判断的是地址是否相等,即判定是不是同一个对象
equals是Object类中的方法
- 1**.**只能判断引用类型
- 2.默认判断的是地址是否相等,子类中往往重写该方法,用于判断内容是否相等
java
package com.hspedu.object_;
public class Equals01 {
public static void main(String[] args) {
A a = new A();
A b = a;
A c = b;
System.out.println(a == c);//true
System.out.println(b == c);//true
B bObj = a;
System.out.println(bObj == c);//true
int num1 = 10;
double 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;
char v2[] = anotherString.value;
int i = 0;
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);//false
System.out.println(integer1.equals(integer2));//true
String str1 = new String("hspedu");
String str2 = new String("hspedu");
System.out.println(str1 == str2);//false
System.out.println(str1.equals(str2));//true
}
}
class B {}
class A extends B {}
如何重写equals方法
应用实例: 判断两个Person对象的内容是否相等,如果两个Person对象的各个属性值都一样,则返回true,反之false。
java
package com.hspedu.object_;
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,反之false
class Person{ //extends Object
private String name;
private int age;
private char gender;
//重写Object 的 equals方法
public boolean equals(Object obj) {
//判断如果比较的两个对象是同一个对象,则直接返回true
if(this == obj) {
return 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 ,则直接返回false
return 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(int age) {
this.age = age;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
}
hashCode 方法
hashCode方法返回对象的哈希码值,该方法是为了提高哈希表的性能
作用
1.提高具有哈希结构的容器的效率
2.两个引用,如果指向的是同一个对象,则哈希值一定是一样的
3.两个引用,如果指向的是不同对象,哈希值是不一样的
4.哈希值主要是根据地址号来的,不能完全将哈希值等价于地址
5.集合中的hashCode根据需要可以进行重写
java
package com.hspedu.object_;
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 {}
toString方法
基本介绍
- toString方法返回对象的字符串表示
默认返回:全类名(包名+类名getClass().getName())+@+哈希值的十六进制 - 子类往往会重写toString方法,用于返回对象的属性信息
重写toString方法,打印对象或拼接对象时,会自动调用该对象的toString形式 - 当直接输出一个对象时,toString方法会被默认调用
System.out.println(monster);//等价于调用monster.toString();
java
package com.hspedu.object_;
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
@Override
public String toString() { //重写后,一般是把对象的属性值输出,当然程序员也可以自己定制
return "Monster{" +
"name='" + name + '\'' +
", job='" + job + '\'' +
", sal=" + sal +
'}';
}
@Override
protected void finalize() throws Throwable {
System.out.println("fin..");
}
}
finalize方法
当垃圾回收期确定不存在对该对象的更多引用时,由对象的垃圾回收器调用此方法
- 1.当对象被回收时,系统会自动调用该方法的finalize方法,子类考研重写该方法,做一些释放资源,数据库连接,打开文件的操作
- 2.什么时候被回收:当某个对象没有任何引用时,jvm就认为这个对象是一个垃圾对象,就会使用回收机制来销毁该对象,在销毁该对象前,会先调用finalize方法
- 3.垃圾回收机制的调用,是由系统来决定的,即有自己的GC,也可以通过System.gc()触发垃圾回收机制
java
package com.hspedu.object_;
//演示 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
@Override
protected void finalize() throws Throwable {
System.out.println("我们销毁 汽车" + name );
System.out.println("释放了某些资源...");
}
}