java（oop中级）

8.oop（中级）

包

命名规则： 只能包含数字、字母、下划线、小圆点，不能以数字开头，不能是关键字或保留字

访问修饰符

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

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

4 种访问修饰符的访问范围

注意事项

OOP

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

封装

封装（encapsulation）：就是把抽象出的数据[ 属性 ] 和对数据的操作[ 方法 ] 封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作[ 方法 ]，才能对数据进行操作。
封装好处：
（1）隐藏实现细节
（2）可以对数据进行验证，保证安全合理
封装实现步骤:

继承

（1）父类又叫 超类， 基类
（2）子类又叫 派生类
继承好处：
（1）代码的复用性提高
（2）代码的扩展性和维护性提高
继承的细节：

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

class A{
A(){System.out.println（"a"）；}
A（String name）{System.out.printin（"a name"）；}
class B extends A{
B(){this（"abc"）；System.out.println（"b"）；}
B（String name）{System.out.println（"b name"）；}
//分析有默认的main中：B b = new B()；会输出什么？
输出结果：a，b name，b//
//B（String name）{
// super();注意继承关系中，构造器有隐藏的 super();
//System.out.println（"b name"）；}

super关键字

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

super的好处：

（1）调用父类的构造器的好处（分工明确，父类属性由父类初始化，子类属性由子类初始化）
（2）当子类中有和父类中的成员（属性和方法）重名时，为了访问父类的成员，必须通过super。
如果没有重名，使用super、this、直接访问效果一样！
（3）super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；如果多个基类（上级类）中都有同名的成员，使用super访问遵循就近原则。 A->B->C
super和this的比较

方法重写/覆盖（override）

方法重写也叫方法覆盖，满足以下条件：
（1）子类的方法的形参列表，方法名称，要和父类的形参列表，方法名称完全一致。
（2）子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类
（3）子类方法不能缩小父类方法的访问权限
【public>protected>默认>private】

多态

方法或对象具有多种形态。
具体体现：
（1）方法的多态：重写和重载
（2）对象的多态
Tips
1）一个对象的编译类型和运行类型可以不一致
2)编译类型在定义对象时，就确定不可更改
3）运行类型是可以变化的
4）编译 看“ = ” 左边 ，运行 看 “ = ” 右边
速记：1.编译看左边，运行看右边
           2.对象属性看编译类型，方法看运行类型
           3.属性没有重写之说！属性的值看编译类型

细节：
多态的前提：两个类（ 对象 ） 存在继承关系
*多态的向上转型：

1. 本质：父类的引用指向子类的对象
2. 语法：父类类型 引用名 = new 子类类型 （）；
3. 特点：编译看左边，执行看右边。
             可以调用父类中的所有成员（需遵守访问权限），不能调用子类中特有成员；最终运行效果看子类的具体实现。

*多态的向下转型：
1）语法：子类类型     引用名=（子类类型）父类引用；
2）只能强转父类的引用，不能强转父类的对象
3）要求父类的引用必须指向的是当前目标类型的对象
4）当向下转型后，可以调用子类类型中所有的成员
————————————————————————————
instanceOf 比较操作符，用于判断对象的运行类型是否为 XX 类型或 XX 类型的子类型

public class test {
    public static void main(String[] args) {
        BB bb = new BB();
        AA aa = new BB();
        System.out.println(aa instanceof AA);//true
        System.out.println(aa instanceof BB);//true
        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的动态绑定机制
（1）当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定
（2）当调用对象属性时，没有动态绑定机制，哪里声明，那里使用
属性看编译 方法看运行

public class DynamicBinding { public static void main(String[] args) {
//a 的编译类型 A, 运行类型 B
A a = new B();//向上转型
 System.out.println(a.sum());//?40 -> 30 
 System.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() {//父类 getI
  return 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;
    // } }

多态的应用
1）多态数组
数组的定义类型为父类类型，里面保存的实际元素类型为子类类型
2）多态参数
方法定义的形参类型为父类类型，实参类型允许为子类类型

Object类详解

== 和 equals方法对比
==是一个比较运算符

1. = =：既可以判断基本类型，又可以判断引用类型
2. = =：如果判断基本类型，类型的值是否相等
3. = =：如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象
4. equals：是Object类中的方法，只能判断引用类型
5. 默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等

public class EqualsExercise02 { 
public static void main(String[] args) { 
Person_ p1 = new Person_(); 
p1.name = "hspedu";
Person_ p2 = new Person_(); 
p2.name = "hspedu";
 System.out.println(p1==p2); //False
 System.out.println(p1.name .equals( p2.name));//T（比较的字符串内容，string的equals方法已重写）
 System.out.println(p1.equals(p2));//False
 String s1 = new String("asdf"); 
 String s2 = new String("asdf"); 
 System.out.println(s1.equals(s2));//T
 System.out.println(s1==s2); //F
 	} 
 }

class Person_{//类
public String name; 
}

hashCOde方法

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

toString方法

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

System.out.println(monster)；

就会默认调用 monster.toString()

finalize方法

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

断点调试
在断点调试过程中，是运行状态，是以对象的运行类型来执行的。

现有Person类，里面有方法run、eat，Student类继承了Person类，并重写了run方法，
自定义了study方法，试写出对象向上转型和向下转型的代码，并写出各自都可以调用哪些方法，
并写出方法输出什么？

class Person{//父类
public void run（）{System.out.printin（""person run"）；}
public void eat（）{System.out.println（"person eat"）；}

class Student extends Person{//子类
public void run（）{System.out.printin（""student run"）；}
public void study（）{System.out.println（"student study."）；}

答案：
∥向上转型：父类的引用指向子类对象
Person p=new Student（）；
p.run()；//student run
p.eat（）；//person eat
/ 向下转型：把指向子类对象的父类引用，转成指向子类对象的子类引用
Student s=（Student）p；
s.run();//student run
s.study();//student study..
s.eat();//person eat

= = 和 equals 的区别

名称	概念	用于基本数据类型	用于引用类型
= =	比较运算符	可以，判断值是否相等	可以，判断两个对象是否相等
equals	Object类的方法，java类都可以使用equals	不可以	可以，默认是判断两个对象是否相等，但是子类往往重写该方法，比较该对象的属性是否相等，比如（String，Integer）

什么是多态，多态具体体现有哪些？
多态：方法或对象具有多种形态，是OOP的第三大特征，是建立在封装和继承基础之上多态具体体现
1.方法多态
（1）重载体现多态
（2）重写体现多态
2.对象多态
（1）对象的编译类型和运行类型可以不一致，编译类型在定义时，就确定，不能变化
（2）对象的运行类型是可以变化的，可以通过getClasss（）来查看运行类型
（3）编译类型看定时时=号的左边，运行类型看=号右边

java的动态绑定机制是什么？
1.当调用对象的方法时，该方法会和对象的内存地址/运行类型绑定
2.当调用对象的属性时，没有动态绑定机制，哪里声明，那里使用