Java面向对象

Java面向对象

---

继承

1. 继承

   • extends关键字

   • instanceof关键字

   • 方法的重写

   • final关键字

   • 继承和组合

2. Object类

   • 基本特性

   java所有类的父类。

   • toString方法

   public String toString(){
       return getClass().getName() + "@" + Integer.toHexString(hashCode());
   }
   //打印完整的类名@地址
   

   • ==和equals方法

   public boolean equals(Object obj){
       return (this == obj);
   }
   
   public class User{
       int id;
       
       User(int id,String name,String pwd){
           this.id = id;
       }
       
       public static void main(String[] args){
           /*
           测试1
           两个对象的地址和内容都不同。
           */
           User u1 = new User("1001");
           User u2 = new User("1002");
           System.out.println(u1.equals(u2));
           // == 用于判断两者是否为同一对象，结果显而易见为false
           
           /*
           测试2
           两个对象的地址不同内容相同
           */
           User u3 = new User("1003");
           User u4 = new User("1003");
           System.out.println(u3.equals(u4));
           //尽管内容一样，但并不是同一对象，所以false，但这样显然不符合我们的认知，同样的Id应该只能代表一人，所以我们可以进行equals()方法的重写。
           @override
           public boolean equals(Object obj){
               if(obj == null){
                   return false;
               }else{
                   if(obj instanceof User){
                       User u = (User)obj;
                       if(u.id == this.id)
                           return ture;
                   }
               }
               return false;
           }
           System.out.println(u3.equals(u4));
           //结果返回true了。
       }
   }
   

   • super关键字

   含义：直接父类对象的引用。

   1. 可以通过super来访问父类中被子类覆盖的方法
   2. 可以通过super来访问父类中被子类覆盖的属性
   3. 调用父类中的构造方法。
   • 继承树追溯

封装

封装的优点：

• 提高代码的安全性
• 提高代码的复用性
• “高内聚”：封装细节，便于修改内部代码，提高可维护性。
• “低耦合”：简化外部调用，便于调用者使用，便于扩展和协作。

四个访问控制符

修饰符	同一类	同一包	子类	所有类
private	*
default	*	*
protected	*	*	*
public	*	*	*	*

多态

同一个方法调用，由于对象不同可能会有不同的行为。

多态的要点：

• 多态是方法的多态，不是属性的多态（多态与属性无关）。
• 多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象。
• 父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

对象的转型