Java学习第四周(1)--面向对象的多态性

学习目标：
1. Object类的toString()与equals(Object  obj)方法
2. 面向对象的多态性

3. 抽象类与接口

一：Object类

1.toString()方法

   public  String toString()方法，其返回值是String类型，描述当前对象的有关信息。
   如果直接打印某对象的引用，则默认会调用这个对象的toString()方法，默认打印的内容中包含这个引用所指向的内存地址。
可以根据需要在用户自定义类中重写toString()方法。

实例:

public class Student{
private String name;
private int age;
private double score;

       构造方法

       getXXX

       setXXX

        public String toString() {
        return "Student [name=" + name + ", age=" + age + ", score=" + score+ "]";

public class ToStringDemo {
public static void main(String[] args) {
Student stu=new Student("张三",20,83.5);
                System.out.println(stu);
}
}

个人理解：在Student 类中，对toString()进行了重写，若不对toString方法进行重写，则会默认打印出stu对象的地址信息，得不到实例化后的结果。

2.equals()方法

public boolean equals(Object obj) 方法，提供定义对象是否“相等”的逻辑。

Object的equals方法定义为：x.equals(y)，当x和y指向同一个地址时返回true，否则返回false。
String类中已经重写了equals(Object  obj)方法，重写后的方法比较的是两个字符串的”内容”是否一样(注意：==比较对象的引用)。
可以根据需要在用户自定义类型中重写equals方法。

实例：

和上一个例子一样使用Student类

public class EqualsDemo {
public static void main(String[] args) {
Student stu1=new Student("哈哈",16,84);
Student stu2=new Student("哈哈",16,84);
System.out.println("stu1与stu2相等吗？"+stu1.equals(stu2));
}
}

个人理解：在对Student类实例化了两个对象后，虽然其中的变量赋值一样，但是使用equals()方法后还是会被认为是不相同的，因为此时比较的是两个对象在内存中的地址，明显不同，这时需要对其进行重写。

二:多态性

是由封装性和继承性引出的面向对象程序设计语言的另一特征

1.多态的体现

（1）方法的重载与重写

（2）对象的多态性主要分为两种：
向上转型： 子类对象->父类对象  (程序会自动完成)
 格式：父类 父类对象=子类实例

向上转型后，因为操作的是父类对象，所以无法找到在子类中定义的新方法;但如果子类重写了父类的某个方法，则调用的是重写后的方法。

实例：

public class Person {
private String name;
private int age;

        构造方法  getXXX   setXXX

        public void say() {
System.out.println("父类，姓名：" + this.name + ";年龄：" + this.age);
}
public void learn(){
System.out.println("父类的学习...");
}

}

public class Student extends Person {

private double score;

        构造方法  getXXX   setXXX

        public void learn() {
System.out.println("子类：学习...");
}

}

public static void main(String[] args) {
Student stu=new Student("哈哈",16,84);
Person per=stu;  
per.say();
per.learn();
}

个人理解：在此例中，Student类继承了Person 类的方法，并重写了learn方法，所以在实例化后调用的是重写后的方法，而say方法没有被重写，所以调用的是原方法

向下转型：父类对象->子类对象 (必须明确的指明要转型的子类类型)

格式：子类 子类对象=(子类)父类实例

注意：向下转型前先要向上转型。

实例：

和上一个例子一样使用Person类和Student类

public static void main(String[] args) {
Person per=new Student("哈哈",16,84); 
Student stu=(Student)per;  
        stu.learn();
}

2.几个关键字（instanceof，final）

(1)使用instanceof关键字判断一个对象是否属于一个类的实例
格式： 对象  instanceof  类名(返回boolean类型)

(2)使用final来修饰,在声明类、属性和方法时

注意：
     [1]final修饰变量(成员变量或局部变量),则成为常量，只能赋值一次
      修饰成员变量时，定义时同时给出初始值，而修饰局部变量时不做要求。

     [2]final修饰方法，则该方法不能被子类重写
      final 返回值类型  方法名(参数列表) { … }
     [3]final修饰类，则类不能被继承
      final class 类名{ … }

三：抽象类

1.抽象类：用abstract修饰的类即为抽象类
  格式：abstract class 抽象类名{ }

抽象类不能被实例化，必须被继承

2.抽象方法：由abstract修饰的方法就是抽象方法，抽象方法没有方法体。

抽象方法必须被重写，生成它的子类。

抽象类不一定要包含抽象方法，若类中包含了抽象方法，则该类必须被定义为抽象类

如果一个子类没有实现抽象父类中所有的抽象方法，则子类也成为一个抽象类。
构造方法、静态方法、私有方法、final方法不能被声明为抽象的方法。

实例：

public abstract  class Person{
   private String name;
   构造方法  getXXX   setXXX
   public abstract void work();  
}

public class Lawyer extends Person{
private int age;

构造方法  getXXX   setXXX

        public void work() {
        System.out.println("律师在法院上班");
}

}

public static void main(String[] args) {
Person per=new Lawyer();   
per.work();
}

个人理解：Person类的抽象方法只声明，不实现，Lawyer继承了Person类的方法并重写，先由Lawyer对象向Lawyer对象转型，再进行调用。

四：接口

接口（interface）是抽象方法和常量值的定义的集合。

从本质上讲，接口是一种特殊的抽象类，这种抽象类中只能包含常量和方法的定义，而没有变量和方法的实现。

1.接口的声明语法

[public] interface 接口名称[extends 父接口列表] { 接口体  }

接口体：包括常量定义和方法定义
常量定义: 类型 名称=赋值;  该常量被实现该接口的多个类共享; 具有public ,final, static的属性（默认）.
方法定义:具有 public，abstract属性（默认）

2.接口实现

接口的使用要通过子类，子类通过implements关键字实现接口。
一个类可以实现多个接口,在implements子句中用逗号分开。非抽象子类必须实现接口中定义的所有方法。

格式：class 子类 implements 接口A，接口B…{ }

3.使用规则

在接口中声明方法时，不能使用static，final，synchronized，private，protected等修饰符。
一个接口可以继承自另一个接口,且允许接口的多继承。
4.接口的用途

(1)通过接口实现不相关类的相同行为,而无需考虑这些类之间的关系.
(2)通过接口指明多个类需要实现的方法
(3)通过接口了解对象的交互界面,而无需了解对象所对应的类

实例：

public interface Fly {
       public static final int SPEED=200;    声明了一个常量
       public abstract void fly();
}

public class Bird implements Fly{
public void fly() {
System.out.println("小鸟飞翔...");
}
}

public static void main(String[] args) {
Fly f=new Bird();
f.fly();
}