Java学习笔记六、面向对象编程中级部分

包
- 包的注意事项和使用细节
访问修饰符
- 访问修饰符的注意事项和使用细节
面向对象编程三大特征
封装
- 封装的实现步骤(三步)
继承
- 继承的细节问题
- 继承的本质
super 关键字
- super给编程带来的便利/细节
- super和this的比较
方法重写/覆盖(override)
- 注意事项和使用细节
- 重载和重写
多态
- 多态的具体体现
- - 方法的多态
  - 对象的多态
- 8.11.5 多态注意事项和细节讨论
- java的动态绑定机制！！！
- 多态数组
- 多态参数
Object类
- == 和equals的对比
- 重写 equals 方法
- hashCode方法
- toString方法
- finalize方法

包

包的作用

区分相同名字的类
当类很多时，可以很好的管理类
控制访问范围

基本语法
package com.edu;

package关键字，表示打包
com.edu表示包名

包的注意事项和使用细节

package的作用是声明当前类所在的包，需要放在类的最上面，一个类中最多只有一句package
import指令位置放在package的下面，在类定义前面，可以有多句且没有顺序要求

//package 的作用是声明当前类所在的包，需要放在类(或者文件)的最上面，
// 一个类中最多只有一句 package
package com.edu.pkg;//import 指令 位置放在 package 的下面，在类定义前面,可以有多句且没有顺序要求
import java.util.Scanner;
import java.util.Arrays;//类定义
public class PkgDetail {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);int[] arr = {0, -1, 1};Arrays.sort(args);}
}

访问修饰符

Java 提供四种访问控制修饰符号，用于控制方法和属性(成员变量)的访问权限（范围）:

公开级别:用 public 修饰,对外公开
受保护级别:用 protected 修饰,对子类和同一个包中的类公开
默认级别:没有修饰符号,向同一个包的类公开
私有级别:用 private 修饰,只有类本身可以访问,不对外公开

访问修饰符的注意事项和使用细节

修饰符可以用来修饰类中的属性，成员方法以及类
只有默认的和public才能修饰类，并且遵循上述访问权限的特点
成员方法的访问规则和属性完全一样

package com.edu.modifier;public class A {//四个属性,分别使用不同的访问修饰符来修饰public int n1 = 100;protected int n2 = 200;int n3 = 300;private int n4 = 400;public void m1() {//在同一类中，可以访问 public protected 默认 private 修饰属性和方法System.out.println("n1=" + n1 + " n2=" + n2 + " n3=" + n3 + " n4=" + n4);}protected void m2() { }void m3() { }private void m4() { }public void hi() {//在同一类中，可以访问 public protected 默认 private 修饰属性和方法m1();m2();m3();m4();}
}

package com.edu.modifier;public class B {public void say() {A a = new A();//在同一个包下，可以访问 public , protected 和 默认修饰属性或方法,不能访问 private 属性或方法System.out.println("n1=" + a.n1 + " n2=" + a.n2 + " n3=" + a.n3 );a.m1();a.m2();a.m3();//a.m4(); 错误的}
}

package com.edu.modifier;public class Test {public static void main(String[] args) {A a = new A ();a.m1();B b = new B();b.say();}
}
//只有 默认和 public 可以修饰类
class Tiger{ }

面向对象编程三大特征

封装、继承和多态

封装

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

隐藏实现细节:方法(连接数据库) <–调用(传入参数…)
可以对数据进行验证，保证安全合理

封装的实现步骤(三步)

将属性进行私有化private [不能直接修改属性]
提供一个公共的(public)set方法，用于对属性判断并赋值

public void setXxx(类型参数名){//Xxx表示某个属性//加入数据验证的业务逻辑属性=参数名;
}

提供个公共的(public)get方法，用于获取属性的值

public数据类型getXxx(){ //权限判断,Xxx某个属性return xX;
}

继承

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

class子类extends父类{}
//1.子类就会自动拥有父类定义的属性和方法
//2.父类又叫超类，基类。
//3.子类又叫派生类。

继承的细节问题

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

package com.edu.extend_;public class ExtendsDetail {public static void main(String[] args) {// System.out.println("===第 1 个对象====");// Sub sub = new Sub(); //创建了子类对象 sub// System.out.println("===第 2 个对象====");// Sub sub2 = new Sub("jack"); //创建了子类对象 sub2System.out.println("===第 3 对象====");Sub sub3 = new Sub("king", 10); //创建了子类对象 sub2//sub.sayOk();}
}

package com.edu.extend_;public class TopBase { //父类是 Objectpublic TopBase() {//super(); Object 的无参构造器System.out.println("构造器 TopBase() 被调用...");//1}
}

package com.edu.extend_;public class Base extends TopBase { //父类//4 个属性public int n1 = 100;protected int n2 = 200;int n3 = 300;private int n4 = 400;public Base() { //无参构造器System.out.println("父类 Base()构造器被调用....");}public Base(String name, int age) {//有参构造器//默认 super()System.out.println("父类 Base(String name, int age)构造器被调用....");}public Base(String name) {//有参构造器System.out.println("父类 Base(String name)构造器被调用....");}//父类提供一个 public 的方法,返回了 n4public int getN4() {return n4;}public void test100() {System.out.println("test100");}protected void test200() {System.out.println("test200");}void test300() {System.out.println("test300");}private void test400() {System.out.println("test400");}//callpublic void callTest400() {test400();}
}

package com.edu.extend_;import java.util.Arrays;
//输入 ctrl + H 可以看到类的继承关系
public class Sub extends Base { //子类public Sub(String name, int age) {//1. 要调用父类的无参构造器, 如下或者 什么都不写,默认就是调用 super()//super();//父类的无参构造器//2. 要调用父类的 Base(String name) 构造器//super("edu");//3. 要调用父类的 Base(String name, int age) 构造器super("king", 20);//细节： super 在使用时，必须放在构造器第一行//细节: super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器//this() 不能再使用了System.out.println("子类 Sub(String name, int age)构造器被调用....");}public Sub() {//无参构造器//super(); //默认调用父类的无参构造器super("smith", 10);System.out.println("子类 Sub()构造器被调用....");}//当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器public Sub(String name) {super("tom", 30);//do nothing...System.out.println("子类 Sub(String name)构造器被调用....");}public void sayOk() {//子类方法//非私有的属性和方法可以在子类直接访问//但是私有属性和方法不能在子类直接访问System.out.println(n1 + " " + n2 + " " + n3);test100();test200();test300();//test400();错误//要通过父类提供公共的方法去访问System.out.println("n4=" + getN4());callTest400();//}
}

继承的本质

package com.edu.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);//false//System.out.println(son.getAge());//返回的就是 39System.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 关键字

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

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

package com.edu.super_;public class Super01 {public static void main(String[] args) {B b = new B();//子类对象b.sum();b.test();}
}

package com.edu.super_;public class Base { //父类是 Objectpublic int n1 = 999;public int age = 111;public void cal() {System.out.println("Base 类的 cal() 方法...");}public void eat() {System.out.println("Base 类的 eat().....");}
}

package com.edu.super_;public class A extends Base{//4 个属性public int n1 = 100;protected int n2 = 200;int n3 = 300;private int n4 = 400;public A() {}public A(String name) {}public A(String name, int age) {}public void cal() {System.out.println("A 类的 cal() 方法...");}public void test100() {}protected void test200() {}void test300() {}private void test400() {}
}

package com.edu.super_;public class B extends A {public int n1 = 888;//编写测试方法public void test() {//super 的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用 super 去访问爷爷类的成员；// 如果多个基类(上级类)中都有同名的成员，使用 super 访问遵循就近原则。A->B->CSystem.out.println("super.n1=" + super.n1);super.cal();}//访问父类的属性 , 但不能访问父类的 private 属性public void hi() {System.out.println(super.n1 + " " + super.n2 + " " + super.n3 );}public void cal() {System.out.println("B 类的 cal() 方法...");}public void sum() {System.out.println("B 类的 sum()");//希望调用父类-A 的 cal 方法//这时，因为子类 B 没有 cal 方法，因此我可以使用下面三种方式//找 cal 方法时(cal() 和 this.cal())，顺序是:// (1)先找本类，如果有，则调用// (2)如果没有，则找父类(如果有，并可以调用，则调用)// (3)如果父类没有，则继续找父类的父类,整个规则，就是一样的,直到 Object 类// 提示：如果查找方法的过程中，找到了，但是不能访问， 则报错, cannot access// 如果查找方法的过程中，没有找到，则提示方法不存在//cal();this.cal(); //等价 cal//找 cal 方法(super.call()) 的顺序是直接查找父类，其他的规则一样//super.cal();//演示访问属性的规则//n1 和 this.n1 查找的规则是//(1) 先找本类，如果有，则调用//(2) 如果没有，则找父类(如果有，并可以调用，则调用)//(3) 如果父类没有，则继续找父类的父类,整个规则，就是一样的,直到 Object 类// 提示：如果查找属性的过程中，找到了，但是不能访问， 则报错, cannot access// 如果查找属性的过程中，没有找到，则提示属性不存在System.out.println(n1);System.out.println(this.n1);//找 n1 (super.n1) 的顺序是直接查找父类属性，其他的规则一样System.out.println(super.n1);}//访问父类的方法，不能访问父类的 private 方法 super.方法名(参数列表);public void ok() {super.test100();super.test200();super.test300();//super.test400();//不能访问父类 private 方法}//访问父类的构造器：super(参数列表);只能放在构造器的第一句，只能出现一句！public B() {//super();//super("jack", 10);super("jack");}}

super给编程带来的便利/细节

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

super和this的比较

方法重写/覆盖(override)

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

注意事项和使用细节

子类的方法的形参列表,方法名称,要和父类方法的形参列表，方法名称完全一样。
子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类
子类方法不能缩小父类方法的访问权限[演示] public > protected >默认> private

package com.edu.override_;public class Override01 {public static void main(String[] args) {//演示方法重写的情况Dog dog = new Dog();dog.cry();//ctrl+b}
}

package com.edu.override_;public class Animal {public void cry() {System.out.println("动物叫唤..");}public Object m1() {return null;}public String m2() {return null;}public AAA m3() {return null;}protected void eat() {}
}

package com.edu.override_;public class Dog extends Animal{//1. 因为 Dog 是 Animal 子类//2. Dog 的 cry 方法和 Animal 的 cry 定义形式一样(名称、返回类型、参数)//3. 这时我们就说 Dog 的 cry 方法，重写了 Animal 的 cry 方法public void cry() {System.out.println("小狗汪汪叫..");}//细节: 子类方法的返回类型和父类方法返回类型一样，// 或者是父类返回类型的子类比如 父类 返回类型是 Object ,// 子类方法返回类型是 Stringpublic String m1() {return null;}//这里 Object 不是 String 的子类，因此编译错误// public Object m2() {//      return null;// }// public BBB m3() {//      return null;// }//细节: 子类方法不能缩小父类方法的访问权限//public > protected > 默认>privatepublic void eat() {}
}class AAA { }
class BBB extends AAA { }

重载和重写

多态

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

多态的具体体现

方法的多态

package com.edu.poly_;public class PolyMethod {public static void main(String[] args) {//方法重载体现多态A a = new A();//这里我们传入不同的参数，就会调用不同 sum 方法，就体现多态System.out.println(a.sum(10, 20));System.out.println(a.sum(10, 20, 30));//方法重写体现多态B b = new B();a.say();b.say();}
}class B { //父类public void say() {System.out.println("B say() 方法被调用...");}
}class A extends B {//子类public int sum(int n1, int n2){//和下面 sum 构成重载return n1 + n2;}public int sum(int n1, int n2, int n3){return n1 + n2 + n3;}public void say() {System.out.println("A say() 方法被调用...");}
}

对象的多态

一个对象的编译类型和运行类型可以不一致
编译类型在定义对象时，就确定了，不能改变
运行类型是可以变化的.
编译类型看定义时=号的左边，运行类型看=号的右边

package com.edu.poly_;public class PolyObject {public static void main(String[] args) {//体验对象多态特点//animal 编译类型就是 Animal , 运行类型 DogAnimal animal = new Dog();//因为运行时 , 执行到改行时，animal 运行类型是 Dog,所以 cry 就是 Dog 的 cryanimal.cry(); //小狗汪汪叫//animal 编译类型 Animal,运行类型就是 Catanimal = new Cat();animal.cry(); //小猫喵喵叫}
}

package com.edu.poly_;public class Animal {public void cry() {System.out.println("Animal cry() 动物在叫....");}
}

package com.edu.poly_;public class Cat extends Animal {public void cry() {System.out.println("Cat cry() 小猫喵喵叫...");}
}

package com.edu.poly_;public class Dog extends Animal {public void cry() {System.out.println("Dog cry() 小狗汪汪叫...");}
}

8.11.5 多态注意事项和细节讨论

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

本质:父类的引用指向了子类的对象
语法:父类类型
引用名= new子类类型();
特点:编译类型看左边，运行类型看右边。
可以调用父类中的所有成员(需遵守访问权限)，
不能调用子类中特有成员;
最终运行效果看子类的具体实现

多态向下转型

语法:子类类型
引用名=(子类类型)父类引用;
只能强转父类的引用，不能强转父类的对象
要求父类的引用必须指向的是当前目标类型的对象
当向下转型后，可以调用子类类型中所有的成员

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

package com.edu.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,你好");}
}

package com.edu.poly_.detail_;public class Cat extends Animal {public void eat(){//方法重写System.out.println("猫吃鱼");}public void catchMouse(){//Cat 特有方法System.out.println("猫抓老鼠");}
}

package com.edu.poly_.detail_;public class Dog extends Animal {//Dog 是 Animal 的子类
}

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

package com.edu.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.edu.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);// trueSystem.out.println(aa instanceof BB);// trueObject 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 {}//子类

java的动态绑定机制！！！

package com.edu.poly_.dynamic_;public class DynamicBinding {public static void main(String[] args) {//a 的编译类型 A, 运行类型 BA a = new B();//向上转型//System.out.println(a.sum());//?40 -> 30System.out.println(a.sum1());//?30-> 20//方法调用看运行类型，属性调用哪里声明哪里使用}
}class A {//父类public int i = 10;//动态绑定机制:public int sum() {//父类 sum()return getI() + 10;//20 + 10}public int sum1() {//父类 sum1()return i + 10;//10 + 10}public int getI() {//父类 getIreturn i;}
}
class B extends A {//子类public int i = 20;
//     public int sum() {//          return i + 20;
//     }public int getI() {//子类 getI()return i;}
//    public int sum1() {//        return i + 10;
//    }
}

多态数组

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

package com.edu.poly_.polyarr_;public class PolyArray {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++) {//person[i] 编译类型是 Person ,运行类型是是根据实际情况有 JVM 来判断System.out.println(persons[i].say());//动态绑定机制//使用 类型判断 + 向下转型.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("你的类型有误, 请自己检查...");}}}
}

package com.edu.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;}
}

package com.edu.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.edu.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.edu.poly_.polyparameter_;public class PolyParameter {public static void main(String[] args) {Worker tom = new Worker("tom", 2500);Manager milan = new Manager("milan", 5000, 200000);PolyParameter polyParameter = new PolyParameter();polyParameter.showEmpAnnual(tom);polyParameter.showEmpAnnual(milan);polyParameter.testWork(tom);polyParameter.testWork(milan);}//showEmpAnnual(Employee e)//实现获取任何员工对象的年工资,并在 main 方法中调用该方法 [e.getAnnual()]public void showEmpAnnual(Employee e) {System.out.println(e.getAnnual());//动态绑定机制.}//添加一个方法，testWork,如果是普通员工，则调用 work 方法，如果是经理，则调用 manage 方法public void testWork(Employee e) {if(e instanceof Worker) {((Worker) e).work();//有向下转型操作} else if(e instanceof Manager) {((Manager) e).manage();//有向下转型操作} else {System.out.println("不做处理...");}}
}

package com.edu.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.edu.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");}//重写获取年薪方法@Overridepublic double getAnnual() {return super.getAnnual() + bonus;}
}

package com.edu.poly_.polyparameter_;public class Worker extends Employee {public Worker(String name, double salary) {super(name, salary);}public void work() {System.out.println("普通员工 " + getName() + " is working");}@Overridepublic double getAnnual() { //因为普通员工没有其它收入，则直接调用父类方法return super.getAnnual();}
}

Object类

== 和equals的对比

==是一个比较运算符

既可以判断基本类型，又可以判断引用类型
如果判断基本类型，判断的是值是否相等。
如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象

equals: 是0bject类中的方法，只能判断引用类型，

默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等

package com.edu.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);//trueSystem.out.println(b == c);//trueB bObj = a;System.out.println(bObj == c);//trueint num1 = 10;double num2 = 10.0;System.out.println(num1 == num2);//基本数据类型，判断值是否相等//把光标放在 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 方法默认就是比较对象地址是否相同//也就是判断两个对象是不是同一个对象.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("edu");String str2 = new String("edu");System.out.println(str1 == str2);//falseSystem.out.println(str1.equals(str2));//true}
}class B {}
class A extends B {}

重写 equals 方法

package com.edu.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));//false}
}//判断两个 Person 对象的内容是否相等，
//如果两个 Person 对象的各个属性值都一样，则返回 true，反之 falseclass Person{ //extends Objectprivate String name;private int age;private char gender;//重写 Object 的 equals 方法@Overridepublic boolean equals(Object obj) {//判断如果比较的两个对象是同一个对象，则直接返回 trueif(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 ，则直接返回 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(int age) {this.age = age;}public char getGender() {return gender;}public void setGender(char gender) {this.gender = gender;}
}

hashCode方法

提高具有哈希结构的容器的效率
两个引用，如果指向的是同一个对象，则哈希值肯定是一样的
两个引用，如果指向的是不同对象，则哈希值是不一样的
哈希值主要根据地址号来的，不能完全将哈希值等价于地址

toString方法

默认返回：全类名+@+哈希值的十六进制
子类往往重写 toString 方法，用于返回对象的属性信息
重写 toString 方法，打印对象或拼接对象时，都会自动调用该对象的toString 形式
当直接输出一个对象时，toString 方法会被默认的调用, 比如System.out.println(monster)；就会默认调用monster.toString()

package com.edu.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@Overridepublic String toString() { //重写后，一般是把对象的属性值输出，也可以自己定制return "Monster{" +"name='" + name + '\'' +", job='" + job + '\'' +", sal=" + sal +'}';}@Overrideprotected void finalize() throws Throwable {System.out.println("fin..");}
}

finalize方法

当对象被回收时，系统自动调用该对象的 finalize 方法。子类可以重写该方法，做一些释放资源的操作
什么时候被回收：当某个对象没有任何引用时，则 jvm 就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用 finalize 方法。
垃圾回收机制的调用，是由系统来决定(即有自己的 GC 算法), 也可以通过 System.gc() 主动触发垃圾回收机制
实际开发中，几乎不会运用 finalize

package com.edu.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@Overrideprotected void finalize() throws Throwable {System.out.println("我们销毁 汽车" + name );System.out.println("释放了某些资源...");}
}

Java学习笔记六、面向对象编程中级部分相关推荐

java学习笔记15--多线程编程基础2
本文地址:http://www.cnblogs.com/archimedes/p/java-study-note15.html,转载请注明源地址. 线程的生命周期 1.线程的生命周期线程从产生到消亡 ...
java学习笔记14--多线程编程基础1
本文地址:http://www.cnblogs.com/archimedes/p/java-study-note14.html,转载请注明源地址. 多线程编程基础多进程一个独立程序的每一次运行称为 ...
简明Python教程学习笔记_6_面向对象编程
面向对象编程:https://www.liaoxuefeng.com/wiki/897692888725344/923030496738368 面向对象高级编程:https://www.liaoxue ...
Python学习笔记：面向对象编程（2）
前言最近在学习深度学习,已经跑出了几个模型,但Pyhton的基础不够扎实,因此,开始补习Python了,大家都推荐廖雪峰的课程,因此,开始了学习,但光学有没有用,还要和大家讨论一下,因此,写下这些帖 ...
学习笔记----MATLAB面向对象编程入门02--类的方法、构造函数
本系列内容为<MATLAB面向对象编程–从入门到设计模式>学习笔记,特此说明. 定义类的方法类的方法(Method)一般用来查询(Query)对象的状态,或者向对象发出一个命令(Comm ...
Python学习笔记：面向对象编程（4）
前言最近在学习深度学习,已经跑出了几个模型,但Pyhton的基础不够扎实,因此,开始补习Python了,大家都推荐廖雪峰的课程,因此,开始了学习,但光学有没有用,还要和大家讨论一下,因此,写下这些帖 ...
Python学习笔记：面向对象编程（3）
前言最近在学习深度学习,已经跑出了几个模型,但Pyhton的基础不够扎实,因此,开始补习Python了,大家都推荐廖雪峰的课程,因此,开始了学习,但光学有没有用,还要和大家讨论一下,因此,写下这些帖 ...
Python学习笔记：面向对象编程（1）
前言最近在学习深度学习,已经跑出了几个模型,但Pyhton的基础不够扎实,因此,开始补习Python了,大家都推荐廖雪峰的课程,因此,开始了学习,但光学有没有用,还要和大家讨论一下,因此,写下这些帖 ...
JAVA学习笔记之面向对象（一）
作为初入开发的萌新,我根据黑马程序员的教学视频和课件整理总结,记录下自己的JAVA学习,方便巩固和交流.每篇笔记首先回顾知识点,然后贴上代码和执行结果,最后进行小结.若有不正之处或者有疑问,欢迎指出, ...

Java学习笔记六、面向对象编程中级部分

Java学习笔记六、面向对象编程中级部分

包

包的注意事项和使用细节

访问修饰符

访问修饰符的注意事项和使用细节

面向对象编程三大特征

封装

封装的实现步骤(三步)

继承

继承的细节问题

继承的本质

super 关键字

super给编程带来的便利/细节

super和this的比较

方法重写/覆盖(override)

注意事项和使用细节

重载和重写

多态

多态的具体体现

方法的多态

对象的多态

8.11.5 多态注意事项和细节讨论

java的动态绑定机制！！！

多态数组

多态参数

Object类

== 和equals的对比

重写 equals 方法

hashCode方法

toString方法

finalize方法

Java学习笔记六、面向对象编程中级部分相关推荐

最新文章

热门文章

Java学习笔记 六、面向对象编程中级部分

Java学习笔记 六、面向对象编程中级部分

包

包的注意事项和使用细节

访问修饰符

访问修饰符的注意事项和使用细节

面向对象编程三大特征

封装

封装的实现步骤(三步)

继承

继承的细节问题

继承的本质

super 关键字

super给编程带来的便利/细节

super和this的比较

方法重写/覆盖(override)

注意事项和使用细节

重载和重写

多态

多态的具体体现

方法的多态

对象的多态

8.11.5 多态注意事项和细节讨论

java的动态绑定机制！！！

多态数组

多态参数

Object类

== 和equals的对比

重写 equals 方法

hashCode方法

toString方法

finalize方法

Java学习笔记 六、面向对象编程中级部分相关推荐

最新文章

热门文章

Java学习笔记六、面向对象编程中级部分

Java学习笔记六、面向对象编程中级部分

Java学习笔记六、面向对象编程中级部分相关推荐