Java基础09-抽象类与多态

注意:

 1.System.out.println(1 + new Person("abc")); //出错
 2.equals()的重写实例:
  @Override
  public boolean equals(Object obj) {   //形参是Object类型,必须在下面使用向下转型才能使用子类的特有方法,使用instanceof进行辅助检查,达到最后的比较目的
   if(this == obj)
    return true;
    
   if(obj instanceof Person) {
    Person p = (Person)obj;
    if(this.name==null && p.name==null) {
     return this.age==p.age;
    }
    if(this.name!=null) {
     return this.name.equals(p.name) && this.age==p.age;
    }
   }
   return false;
  }
 3.System.currentTimeMillis(); //打印:当前时间距离1970年的间隔时间的毫秒数!!!

一.Object类
 1.java.lang.Object类:
  Object是Java中所有类的父类, 一个类如果不继承任何类, 那么默认继承Object
  Object类中的所有方法都会被子类继承
  
 2.toString()方法
  a.在println或者print方法中打印一个对象的时候, 默认会调用该对象的toString方法, 然后将返回值显示到屏幕
  如:
   Person p = new Person("abc");
   System.out.println(p.toString());
   System.out.println(p);
   
  b.toString方法在Object类中默认返回的是"类名@地址"的形式
  注:
   getClass().getName()+"@"+Integer.toHexString();
   
  c.如果我们不想返回上面的形式, 可以在类中重写toString方法, 通常我们重写后都是返回该类的属性
  如:
   @Override
   public String toString() {
    return this.name+" ,"+this.age;
   }
   
  d.把一个对象和一个String用"+"做运算的时候, 会调用该对象的toString方法先转为String再相加
  如:
   System.out.println(1 + new Person("abc")); //出错
   System.out.println(new Person("abc") +1 ); //正确
   System.out.println("1" + new Person("abc")); //正确
  
 3.equals()方法:
  a."=="与equals()的区别:
  如:
   String s1="abc";
   String s2="abc";
   System.out.println(s1 == s2);      // true
   System.out.println(s1.equals(s2)); // true
   String s3=new String("abc");
   String s4=new String("abc");
   System.out.println(s3 == s4);      // false
   System.out.println(s3.equals(s4)); // false
   
  b.equals():
   比较两个对象是否相同(内容相同),比较字符串的时候, 如果我们希望比较两个字符串的内容是否相同, 那么就可以使用equals方法
   我们调用equals方法比较两个对象, 会先在当前类找是否有equals方法, 如果没有就会找Object类, Object类的equals默认是比较地址.
   
  c.如果我们不想比较地址, 希望按照对象的属性来比较, 就可以重写该方法. String类的equlas方法可以比较String的内容, 就是因为重写了该方法.
  如:
   class Person {
    private String name;
    private int age;
    
    public Person(String name,int age) {
     this.name=name;
     this.age=age;
    }
    
    @Override
    public boolean equals(Object obj) {   //形参是Object类型,必须在下面使用向下转型才能使用子类的特有方法,
                                          //使用instanceof进行辅助检查,达到最后的比较目的
     if(this == obj)
      return true;
      
     if(obj instanceof Person) {
      Person p = (Person)obj;
      if(this.name==null && p.name==null) {
       return this.age==p.age;
      }
      if(this.name!=null) {
       return this.name.equals(p.name) && this.age==p.age;
      }
     }
     return false;
    }
   }

 

二.文档注释:
 1.格式:
  /**
  *
  */

 2.实例:  
  /**
  *这是一个Person类.<br>用于创建Person对象.
  *其是一个带名称属性的对象.
  *@author Liu
  *@version 1.0
  *@since 1.8
  */
  public class Person {                    //必须类使用public修饰
   
   /**
   *Person的名称属性.
   */
   private String name;
   
   /**
   *Person的构造函数.需要传递一String参数.
   *@param name-创建Person对象的名称
   */
   public Person(String name) {
    this.name=name;
   }
   
   /**
   *重写了Object类的toString()方法.
   *@return 返回当前Person对象的名称的字符串.
   */
   @Override
   public String toString() {
    return this.name;
   }
  }
  
 3.CMD编译生成命令:
  javadoc -d . -author -version Person.java
  
  
三.组合设计模式-CompositePattern
 1.什么是组合设计模式
  在定义一个类的时候, 需要使用另一个类的功能时, 可以使用组合设计模式
  
 2.组合设计模式的写法
  a.用构造函数接收要组合的对象
  b.定义成员变量, 记住组合进来的对象
  c.通过成员变量, 调用被组合对象的方法
  
  注:
   class CompositeDemo { 
    public static void main(String[] args) {
     Card c = new CreditCard();
     Person p = new Student(c);
     p.shopping();
     p.eat();
    } 
   }
 
   class Person {      // 人
    private Card card;    // 2.定义成员变量, 记住组合进来的对象
    public Person(Card card) {  // 1.用构造函数接收要组合的对象
     this.card = card;
    }
    public void shopping() {  // 购物
     card.spend();    // 3.通过成员变量, 调用被组合对象的方法
     System.out.println("买了一台iPhone5"); 
    } 
    public void eat() {
     card.spend();
     System.out.println("吃了一顿全聚德");
    }
   }
   
   class Student extends Person {
    public Student(Card card) {
     super(card);
    }
   }
   
   class Card {      // 卡
    public void spend() {   // 刷卡
     System.out.println("刷卡消费, 一不小心刷了100块!");
    }
   }
   
   class CreditCard extends Card {
    public void spend() {   // 刷卡
     System.out.println("刷卡消费, 先欠着!");
    }
   }
  
 3.组合和继承的区别或优点:
  a.组合设计模式不占用继承位置
  b.在只是需要调用, 而没有逻辑上的父级关系时, 不合适用继承
  
四.多态-polymorphism
 1.什么是多态
  多态就是一段代码可以运行出多种形态
  
 2.怎么实现多态
  在定义方法的时候, 形参可以指定为父类类型, 这样所有的子类对象也可以传入, 传入不同的子类对象, 就可以调用不同的方法. 代码就实现了多种形态.
  
五.抽象类 (注: abstract 只修饰类和方法!!)
 1.什么是抽象类
  a.用abstract关键字修饰的类就是抽象类
  b.抽象类中可以定义抽象方法
  c.抽象类不能创建对象
  
 2.怎么定义抽象类
  子类中方法声明和实现都相同的方法: 在父类中声明, 直接实现.
  子类中方法声明相同, 实现不同的方法: 在父类中声明为抽象方法, 子类中实现
  
 3.为什么定义抽象类
  a.有时候多个类中具有相同的方法声明, 而实现方式不同, 我们就可以在父类中定义一个抽象方法, 在子类中实现
  b.父类中还可以将子类中相同的方法定义出来, 这样提高代码复用性.
  c.父类中声明了抽象方法, 虽然没有实现, 但是在子类当作父类来用时, 通过父类变量也能调用到子类的方法, 更好的支持了多态
  d.在别人阅读我们的代码时, 看到了抽象类, 就知道子类都有哪些方法.
  
 4.抽象类的继承
  a.一个抽象类可以继承另一个抽象类
  b.一个普通的类如果继承抽象类, 那么所有的抽象方法必须重写后,才能创建子类对象,否则子类必须使用abstract修饰
  c.抽象类中可以没有抽象方法, 目的就是为了不让别人创建对象, 专门为了给别人继承来用的. GUI中一些Adapter就是这样的抽象类.
  
六.final关键字
 1.类:  最终的类, 不能被继承
 2.方法: 最终的方法,  不能被重写
 3.变量: 最终的变量, 就是常量, 只能赋值一次.
  a.可以用在局部变量, 成员变量, 形参
  b.实际应用: public static final double PI = 3.1415;
  注:
   final int x=4; //x的生命周期,是在程序运行完成后结束!!
  
七.模板设计模式
 1.什么时候用模板设计模式
  在多段代码中有一些代码重复使用的时候, 

 2.怎么使用:
  a.将重复的代码写在一个模板方法中, 不确定的代码定义成一个抽象方法.
  b.在模板方法中调用抽象方法.
  c.定义子类继承该类, 重写抽象方法, 写入不同的代码即可, 原来相同的代码可以从父类继承到, 不用重新再写
 注:
  class TemplateDemo {
   public static void main( String ... args){
    new A().test();
   }
  }
  abstract class Template {
   public final void test() {
    long start=System.currentTimeMillis();
    System.out.println(start);
    
    doSomething();
    
    long end=System.currentTimeMillis();
    System.out.println(end-start);
   }
   
   abstract void doSomething();
  }
  
  class A extends Template {
   @Override
   public void doSomething() {
    //code
    for(int i=0;i<1000;i++) {
     System.out.println(i);
    }
   }
  }