继承、封装、多态

一、继承

1.extends

1.子类继承父类，可以得到父类的全部属性和方法 (除了父类的构造方法)，但不见得可以直接访问(比如，父类私有的属性和方法)。

2.如果定义一个类时，没有调用extends，则它的父类是：java.lang.Object。

public class Test{
  ``public static void main(String[] args) {
    ``Student s = new Student("高淇",172,"Java");
    ``s.rest();
    ``s.study();
  ``}
}
class Person {
  ``String name;
  ``int height;
  ``public void rest(){
    ``System.out.println("休息一会！");
  ``} 
}
class Student extends Person {
  ``String major; //专业
  ``public void study(){
    ``System.out.println("在尚学堂，学习Java");
  ``} 
  ``public Student(String name,int height,String major) {
    ``//天然拥有父类的属性
    ``this.name = name;
    ``this.height = height;
    ``this.major = major;
  ``}
}

2.instanceof

instanceof是二元运算符，左边是对象，右边是类；当对象是右面类或子类所创建对象时，返回true；否则，返回false。

public class test {
  public static void main(String[] args) {
	s a=new s();
	System.out.println(a instanceof s);//返回为true
}
}
class s extends test{	
}

3.方法重写

子类通过重写父类的方法，可以用自身的行为替换父类的行为。方法的重写是实现多态的必要条件。

public class TestOverride {
    public static void main(String[] args) {
        Vehicle v1 = new Vehicle();
        Vehicle v2 = new Horse();
        Vehicle v3 = new Plane();
        v1.run();
        v2.run();
        v3.run();
        v2.stop();
        v3.stop();
    }
}
 
class Vehicle { // 交通工具类
    public void run() {
        System.out.println("跑....");
    }
    public void stop() {
        System.out.println("停止不动");
    }
}
class Horse extends Vehicle { // 马也是交通工具
    public void run() { // 重写父类方法
        System.out.println("四蹄翻飞，嘚嘚嘚...");
    }
}
 
class Plane extends Vehicle {
    public void run() { // 重写父类方法
        System.out.println("天上飞！");
    }
    public void stop() {
        System.out.println("空中不能停，坠毁了！");
    }
}  

4.Object类的基本特性

Object类是所有Java类的根基类，也就意味着所有的Java对象都拥有Object类的属性和方法。如果在类的声明中未使用extends关键字指明其父类，则默认继承Object类

t o String()

Object类中定义有public String toString()方法，其返回值是 String 类型。Object类中toString方法的源码为：

public String toString() {``  ``return getClass().getName() + "@" + Integer.toHexString(hashCode());``}

to Spring方法默认会返回“类名+@+16进制的hashcode”。在打印输出或者用字符串连接对象时，会自动调用该对象的toString()方法。

to Spring()测试和重写

class Person {
    String name;
    int age;
   //默认类名加地址
    public String toString() {
        return name+",年龄："+age;
    }
}
public class test{
    public static void main(String[] args) {
        Person p=new Person();
        p.age=20;
        p.name="李东";
        System.out.println("info:"+p);
         
        test t = new test();
        System.out.println(t);
    }
}

equal()

“==”代表比较双方是否相同。如果是基本类型则表示值相等，如果是引用类型则表示地址相等即是同一个对象。

equal()提供“对象内容相等”的逻辑

Object 的 equals 方法默认就是比较两个对象的hashcode(哈希码)，是同一个对象的引用时返回 true 否则返回 false。但是，我们可以根据我们自己的要求重写equals方法。

equal()测试与重载

public class TestEquals { 
    public static void main(String[] args) {
        Person p1 = new Person(123,"高淇");
        Person p2 = new Person(123,"高小七");     
        System.out.println(p1==p2);     //false，不是同一个对象
        System.out.println(p1.equals(p2));  //true，id相同则认为两个对象内容相同
        String s1 = new String("尚学堂");
        String s2 = new String("尚学堂");
        System.out.println(s1==s2);         //false, 两个字符串不是同一个对象
        System.out.println(s1.equals(s2));  //true,  两个字符串内容相同
    }
}
class Person {
    int id;
    String name;
    public Person(int id,String name) {
        this.id=id;
        this.name=name;
    }
    public boolean equals(Object obj) {
        if(obj == null){
            return false;
        }else {
            if(obj instanceof Person) {
                Person c = (Person)obj;
                if(c.id==this.id) {
                    return true;
                }
            }
        }
        return false;
    }
}

5.super关键字

super是直接父类对象的引用。可以通过super来访问父类中被子类覆盖的方法或属性。

使用super调用普通方法，语句没有位置限制，可以在子类中随便调用。

super关键字的使用

public class TestSuper01 { 
    public static void main(String[] args) {
        new ChildClass().f();
    }
}
class FatherClass {
    public int value;
    public void f(){
        value = 100;
        System.out.println ("FatherClass.value="+value);
    }
}
class ChildClass extends FatherClass {
    public int value;
    public void f() {
        super.f();  //调用父类对象的普通方法
        value = 200;
        System.out.println("ChildClass.value="+value);
        System.out.println(value);
        System.out.println(super.value); //调用父类对象的成员变量
    }
    	}

6.继承树追溯

·属性/方法查找顺序：(比如：查找变量h)

\1. 查找当前类中有没有属性h

\2. 依次上溯每个父类，查看每个父类中是否有h，直到Object

\3. 如果没找到，则出现编译错误。

\4. 上面步骤，只要找到h变量，则这个过程终止。

·构造方法调用顺序：

构造方法第一句总是：super(…)来调用父类对应的构造方法。所以，流程就是：先向上追溯到Object，然后再依次向下执行类的初始化块和构造方法，直到当前子类为止。

注：静态初始化块调用顺序，与构造方法调用顺序一样，不再重复。

继承树执行测试：

public class TestSuper02 { 
    public static void main(String[] args) {
        System.out.println("开始创建一个ChildClass对象......");
        new ChildClass();
    }
}
class FatherClass {
    public FatherClass() {
        System.out.println("创建FatherClass");
    }
}
class ChildClass extends FatherClass {
    public ChildClass() {
        System.out.println("创建ChildClass");
    }
}

二.封装

1.封装的实现——使用访问控制符

\1. private 表示私有，只有自己类能访问

\2. default表示没有修饰符修饰，只有同一个包的类能访问

\3. protected表示可以被同一个包的类以及其他包中的子类访问

\4. public表示可以被该项目的所有包中的所有类访问

2.封装的使用细节

类的属性的处理:

\1. 一般使用private访问权限。

\2. 提供相应的get/set方法来访问相关属性，这些方法通常是public修饰的，以提供对属性的赋值与读取操作(注意：boolean变量的get方法是is开头!)。

\3. 一些只用于本类的辅助性方法可以用private修饰，希望其他类调用的方法用public修饰。

public class Person {
    // 属性一般使用private修饰
    private String name;
    private int age;
    private boolean flag;
    // 为属性提供public修饰的set/get方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public boolean isFlag() {// 注意：boolean类型的属性get方法是is开头的
        return flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

三.多态

1. 多态含义：

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

2.多态的要点：

\1. 多态是方法的多态，不是属性的多态(多态与属性无关)。

\2. 多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象。

\3. 父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了

3.多态与类型转换测试：

class Animal {
    public void shout() {
        System.out.println("叫了一声！");
    }
}
class Dog extends Animal {
    public void shout() {
        System.out.println("旺旺旺！");
    }
    public void seeDoor() {
        System.out.println("看门中....");
    }
}
class Cat extends Animal {
    public void shout() {
        System.out.println("喵喵喵喵！");
    }
}
public class TestPolym {
    public static void main(String[] args) {
        Animal a1 = new Cat(); // 向上可以自动转型
        //传的具体是哪一个类就调用哪一个类的方法。大大提高了程序的可扩展性。
        animalCry(a1);
        Animal a2 = new Dog();
        animalCry(a2);//a2为编译类型，Dog对象才是运行时类型。
         
        //编写程序时，如果想调用运行时类型的方法，只能进行强制类型转换。
        // 否则通不过编译器的检查。
        Dog dog = (Dog)a2;//向下需要强制类型转换
        dog.seeDoor();
    }
 
    // 有了多态，只需要让增加的这个类继承Animal类就可以了。
    static void animalCry(Animal a) {
        a.shout();
    }
 
    /* 如果没有多态，我们这里需要写很多重载的方法。
     * 每增加一种动物，就需要重载一种动物的喊叫方法。非常麻烦。
    static void animalCry(Dog d) {
        d.shout();
    }
    static void animalCry(Cat c) {
        c.shout();
    }*/
}

4.对象转型

父类引用指向子类对象，我们称这个过程为向上转型，属于自动类型转换。

向上转型后的父类引用变量只能调用它编译类型的方法，不能调用它运行时类型的方法。这时，我们就需要进行类型的强制转换，我们称之为向下转型!

public class TestCasting {
    public static void main(String[] args) {
        Object obj = new String("北京尚学堂"); // 向上可以自动转型
        // obj.charAt(0) 无法调用。编译器认为obj是Object类型而不是String类型
        /* 编写程序时，如果想调用运行时类型的方法，只能进行强制类型转换。
         * 不然通不过编译器的检查。 */
        String str = (String) obj; // 向下转型
        System.out.println(str.charAt(0)); // 位于0索引位置的字符
        System.out.println(obj == str); // true.他们俩运行时是同一个对象
    }
}

5.final关键字

final关键字的作用：

\1. 修饰变量: 被他修饰的变量不可改变。一旦赋了初值，就不能被重新赋值。

final` `int`  `MAX_SPEED = ``120``;

\2. 修饰方法：该方法不可被子类重写。但是可以被重载!

final` `void` `study(){}

\3. 修饰类: 修饰的类不能被继承。比如：Math、String等。

final`  `class` `A {}