Java面向对象 --2

22.面向对象特征之二： 继  承     2020-04-29  21:39:33

01.多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么子类无需再定义这些属性和行为，只要继承父类即可。

02.定义方法：
        //定义父类

  public class Person {
              public String name;
              public int age;
              public String getInfo() {...}
        }
        //使用extends关键字定义继承的子类，意即对父类的"扩展".
        public class Student extends Person{
              public String school;
        }

//Student类继承了父类Person的所有属性和方法，并增加了一个属性school.
        //Person中的属性和方法,Student都可以利用.
        //如果子类和父类不在同一个包下，子类只能使用父类中public和protected修饰的成员

03.继承的出现提高了代码的复用性。
       继承的出现让类与类之间产生了关系，提供了多态的前提。
       不要仅为了获取其他类中某个功能而去继承,继承的类之间应该有逻辑性
       子类不能直接访问父类中私有的(private)的成员变量和方法,应通过setter、getter方法访问

04.一个子类只能有一个父类，一个父类可以派生出多个子类，Java支持多层继承，但不支持一个子类多个父类这样的    多重继承

05.方法的重写(override)
        (1).在子类中可以根据需要对从父类中继承来的方法进行改造，子类的方法将覆盖父类的方法,称重写。

(2).方法重写时的注意：
            a.重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值类型。
            b.重写方法不能使用比被重写方法更严格的访问权限。
            c.重写和被重写的方法须同时为static的，或同时为非static的
            d.子类方法抛出的异常不能大于父类被重写方法的异常

(3).重写示例代码：

public class Person {
         public String name;
         public int age;
         public String getInfo() {
         return "Name: "+ name + "\n" +"age: "+ age;
         }
}
public class Student extends Person {
         public String school;
         public String getInfo() {       //重写方法
         return  "Name: "+ name + "\nage: "+ age
              + "\nschool: "+ school;
   }
}

(4).在eclipse中可以使用快捷键 Alt+/ 选择override进行快速重写。

23.关键字super

01.super可用于访问父类中定义的属性，方法，以及父类的构造函数.

02.    a.尤其当子父类出现同名成员时，可以用super进行区分
        b.super的追溯不仅限于直接父类，还可以调用子类之上的所有父类
        c.super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

03.使用方法：可以使用 super.+父类成员 进行调用。

04.注意：
            a.子类中所有的构造器默认都会访问父类中空参数的构造器
            b.当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语 句指定调用本类或者父类中相应的构造器，且必须放在构造器的第一行
            c.如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错

代码示例：

 　　　　　　　　　　//父类
                  public class Person {

                     private String name;
                     private int age;
                    private Date birthDate;    

                     public Person(String name, int age, Date d) {
                            this.name = name;
                            this.age = age;
                             this.birthDate = d;
                      }
                    public Person(String name, int age) {
                             this(name, age, null);
                         }
                    public Person(String name, Date d) {
                             this(name, 30, d);
                         }
                    public Person(String name) {
                             this(name, 30);
                        }

                  }

                //调用父类
                   public class Student extends Person {
                     private String school;

                   public Student(String name, int age, String s) {
                               super(name, age);
                               school = s;
                       }
                     public Student(String name, String s) {
                               super(name);
                              school = s;
                         }
                     public Student(String s) { // 编译出错: no super(),系统将调用父类
                                                                          无参数的构造方法。
                               school = s;
                         }
                  }

24.this和super的区别

25.面向对象的特征之三：多态性

（1）Java中多态性的两种体现：
        01.方法的重载(overload)和重写(overwrite).
                a.重载：本类中允许同名方法存在，体现相同的方法实现不同的逻辑
                b.重写：子类对父类方法的覆盖，子类可以使用和父类相同的方法名，覆盖掉父类的逻辑
        02.对象的多态性 --子类的对象可以替代父类的对象使用,可以直接应用在抽象类和接口上.

03.Java引用变量有两个类型：
            编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。若编译时类型和运行时类型不一致，就出现多态（Polymorphism）

（2）对象的多态性：    
            01.一个变量只能有一种确定的数据类型，但一个引用类型变量可能指向(引用)多种不同类型的对象
                示例：

Person p = new Person();
Person e = new Student(); // Person类型的变量e，指向Student类型的对象

02.子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型(upcasting).
                即子类的对象可以给父类类型的变量作为引用

03.一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，
               那么该变量就不能再访问子类中添加的属性和方法
                   示例：

Student m = new Student();
 m.school = “pku”;     //合法,Student类有school成员变量
 Person e = new Student(); 
 e.school = “pku”;    //非法,Person类没有school成员变量
 //属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误。
            04.虚拟方法调用

//正常的方法调用
Person p = new Person();
p.getInfo();
Student s = new Student();
s.getInfo();
//虚拟方法调用(多态情况下)
Person e = new Student();
e.getInfo();    //调用Student类的getInfo()方法
//编译时类型和运行时类型编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类的getInfo()方法。
//Java的方法是运行在栈内存中的，在运行方法时会动态进栈和出栈--动态绑定.
    (3)多态小结：
            前提：
                需要存在继承或者实现关系
                要有覆盖操作

成员方法：
                编译时：要查看引用变量所属的类中是否有所调用的方法.
                运行时：调用实际对象所属的类中的重写方法.
                成员方法的多态性，也就是多态绑定，必须在有方法的重写前提下才能进行.
            成员变量：
                不具备多态性，只看引用变量所属的类.

26.instanceof操作符

01.x instanceof A：检验x是否为类A的对象，返回值为boolean型.

02.要求x所属的类与类A必须是子类和父类的关系，否则编译错误.

03.如果x属于类A的子类B，x instanceof  A值也为true.

27.Object类

01.Object类是所有Java类的根父类（基类）.
       在多层继承中处于最高层的父类一定是Object类

02.如果在类的声明中未使用extends关键字指明其父类，则默认父类为Object类 
            public class Person {
            ...
            }
            //等价于：
            public class Person extends Object {
            ...
            }

03.可以用于接收作为参数的类.
        //示例：
        method(Object obj){…}//可以接收任何类作为其参数
        Person o=new Person();  
        method(o);

04.Object类中的方法
       Object是所有类的父类，子类可以调用父类的方法，所以Object中的方法在其他所有类中都可以使用 对象.方法()

方法列表：

num  方法  类型 描述
a public Object() 构造 构造方法
b public boolean equals(Object obj) 普通 对象比较
c public int hashCode() 普通 取得Hash码
d public String toString() 普通 对象打印时调用
28.对象类型转换(Casting)

01.对Java对象的强制类型转换称为造型
        a.从子类到父类的类型转换可以自动进行
        b.从父类到子类的类型转换必须通过造型(强制类型转换)实现
        c.无继承关系的引用类型间的转换是非法的
        d.String类是Object类的子类，所以也满足上面的法则
        对象类型转换代码示例：

public class Test{ 
       public void method(Person e){     //设Person类中没有getschool()                        方法
  // System.out.pritnln(e.getschool());   //非法,编译时错误，因为e在形参传入时是Person类的对象,没有.getschool()方法，应该进行判断和转换

       if(e  instanceof  Student){
             Student me = (Student)e;    //将e强制转换为Student类型
             System.out.pritnln(me.getschool());
       }        
  }
 public static  void main(Stirng args[]){
        Test t = new Test();
        Student m = new Student();
        t.method(m);
     }
 }

29.==操作符与equals方法

01. ==操作符
        a.基本类型比较值:只要两个变量的值相等，即为true.
        b.引用类型比较引用(是否指向同一个对象):只有指向同一个对象时(在内存中的地址)，==才返回true.
        c.用“==”进行比较时，符号两边的数据类型必须兼容(可自动转换的基本数据类型除外)，否则编译出错.

02.equals()方法
        a.所有类都继承了Object，也就获得了equals()方法。还可以重写.
        b.只能比较引用类型，其作用与“==”相同,比较是否指向同一个对象(地址)
        c.调用格式：obj1.equals(obj2)
        d.特例：当用equals()方法进行比较时，对类File、String、Date及包装类来说，因为在这些类中重写了Object类的equals()方法，所以比较的是类型及内容，而不是引用的是否是同一个对象.

30.String对象的创建

31.toString()方法

01.toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址。
    02.打印对象时，默认输出对象的内存地址，即输出 对象.toString()

32.包装类(Wrapper)

01.针对八种基本定义相应的引用类型—包装类（封装类）
    02.基本数据类的包装类主要用于基本数据类型与字符串之间的转换
    03.基本数据类型的实例化转为对应的包装类后，就有了类的特点，就可以调用类中的方法。

基础数据类型对应包装类列表

基本数据类型 包装类
boolean Boolean
byte Byte
short Short
int Integer
long Long
char Character
float Float
double Double

04.基本数据类型包装成包装类   ---装箱

//通过包装类的构造器实现：
int i = 500;   Integer t = new Integer(i);
//还可以通过字符串参数构造包装类对象：
Float f = new Float(“4.56”);
    05.获得包装类对象中包装的基本类型变量    ---拆箱

//调用包装类的.xxxValue()方法：
 boolean b = bObj.booleanValue();
    06.JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配。

07.使用包装类进行字符串与基本数据类型之间的转换.

a.字符串转换成基本数据类型
            //通过包装类的构造器实现：
            int i = new Integer(“12”);
            //通过包装类的parseXxx(String s)静态方法：
            Float f = Float.parseFloat(“12.1”);

b.基本数据类型转换成字符串
            //调用字符串重载的valueOf()方法：
            String fstr = String.valueOf(2.34f);
            //更直接的方式：
            String intStr = 5 + “”;