Java三大要点

Java三大要点

------封装、继承、多态

Java三大要点封装继承（extends）重写方法(overrides method)（要在非静态下重写，只能是public）多态(建立在方法重写上)课外题

---

---

 

封装

/*
    1.提高程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.系统可维护增加
 */
​
public class Private {
​
    //私有属性(封装)
    private String name;
    private int age;
    private int toll;
​
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    //防止数据不合法破坏程序
    public void setAge(int age) {
        if (age >=120 || age <=0) {
           this.age = 3;
        } else {
            this.age = age;
        }
    }
​
    public int getToll() {
        return toll;
    }
​
    public void setToll(int toll) {
        this.toll = toll;
    }
}

 

 

继承（extends）

继承就是扩展，子类是父类的扩展。

Java中只有单继承，没有多继承。（一个父类可以有多个子类，一个子类只能有一个父类）

//Java中所有的类都默认直接继承object类
//Animal动物 父类，基类
public class Animal {
​
    public Animal() {
        System.out.println("Animal被调用");
    }
    protected String x = "90";
​
    public void say() {
        System.out.println("say one");
    }
}
​
==============================================================================
==============================================================================
    
//Person人 子类，派生类 (继承父类的所有方法和属性,私有和保护的无法继承）
//ctrl + h 查看继承的层次结构
public class Person extends Animal {
​
    //子类构造器会隐式调用父类无参构造器
    public Person() {
        super();  //调用构造器必须写在构造器第一行
        System.out.println("Person被调用");
    }
​
}
​
==============================================================================
==============================================================================
​
//Man男人 子类，派生类
public class Man extends Person {
​
}

 

• super注意点

  1. 调用父类的构造器必须在构造方法的第一句。

  2. 必须只能出现在子类的放法或构造方法中。

  3. super和this不能同时调用构造方法。

• this&&super代表的对象不同：

  >>this

  ·本身调用者这个对象

  ·没有继承也可以使用

  ·this()本类的构造

  >>super

  ·代表父类对象的应用

  ·只有在继承条件才可以使用

  ·super()父类的构造

重写方法(overrides method)（要在非静态下重写，只能是public）

重写：需要有继承关系，子类重写父类的方法（重写是子类的方法和父类必须一致，方法体不同）

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符范围可以扩大不能缩小
4. 抛出的异常范围可以缩小不能扩大

 

无法重写的情况

    1. static 方法是属于类，不属于实例
    2. final 常量
    3. private

 

public class Animal {
​
      protected String x = "90";
​
    public void say() {
        System.out.println("say one");
    }
}
​
==============================================================================
==============================================================================
​
public class Person extends Animal {    
    //重写方法不重写属性
    public void say() {
        System.out.println("say two");
    }
}
Person r = new Person();
Animal z = new Person();  //父类类型可以引用子类
Animal x = new Animal();
​
r.say();  //输出：say two
z.say();  //输出：say two
x.say();  //输出：say one

 

多态(建立在方法重写上)

多态存在条件

    * 有继承关系
    * 子类重写父类方法
    * 父类引用指向子类对象

Object object = new Person();

 

 多态注意事项

    1. 多态是方法的多态，属性没有多态
    2. 父类和子类，需要有联系   类型转换异常！ClassCastException！
    3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象    Father f1 = new Son();

 

instanceof和类型转换

判断一个对象是什么类是否有父子关系 格式：对象 instanceof 类

//Animal父类
//Person||Dog 继承Animal
//Man||Woman 继承Person
​
Object object1 = new Object();
Object object2 = new Person();
​
System.out.println(object1 instanceof Animal); //false
System.out.println(object2 instanceof Dog);    //false
System.out.println(object2 instanceof Object); //true
System.out.println(object2 instanceof Animal); //true
​
//System.out.println(person1 instanceof Dog);
//System.out.println(person1 instanceof String);  //毫无关系就会报错

<p1>类型转换<p1>

1. 父类引用指向子类对象；

2. 把子类转换为父类，（向上转型）丢失方法；

3. 把父类转换为子列，（向下转型）强制转换；

4. 存在意义：方便方法调用，减少重复的代码。

//Animal父类
//Person||Dog 继承Animal
//Man||Woman 继承Person
​
Man man = new Man();
​
//子类转换为父（小-->大），但可能会丢失自己本来的一些方法
Animal animal = man;
Object object = man;
​
//父类转换为子类（大-->小）需要强制类型转换
Person person = (Person) Animal;

 

课外题

class A {
    public String show(D obj) {
        return ("A and D");
    }
​
    public String show(A obj) {
        return ("A and A");
    }
​
}
​
class B extends A{
    public String show(B obj){
        return ("B and B");
    }
​
    public String show(A obj){
        return ("B and A");
    }
}
​
class C extends B{
​
}
​
class D extends B{
​
}
​
public class Demo {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();
​
        System.out.println("1--" + a1.show(b));
        System.out.println("2--" + a1.show(c));
        System.out.println("3--" + a1.show(d));
        System.out.println("4--" + a2.show(b));
        System.out.println("5--" + a2.show(c));
        System.out.println("6--" + a2.show(d));
        System.out.println("7--" + b.show(b));
        System.out.println("8--" + b.show(c));
        System.out.println("9--" + b.show(d));
    }
}

 当父类对象引用变量引用子类对象时，被引用对象的类型决定了调用谁的成员方法，引用变量类型决定可调用的方法。如果子类中没有覆盖该方法，那么会去父类中寻找。

 

继承链中对象方法的调用的优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O) 

class X {
    public void show(Y y){
        System.out.println("x and y");
    }
​
    public void show(){
        System.out.println("only x");
    }
}
​
class Y extends X {
    public void show(Y y){
        System.out.println("y and y");
    }
    public void show(int i){
​
    }
}
​
class Demo{
    public static void main(String[] args) {
        X x = new Y();
        x.show(new Y());
        x.show();
    }
}

解释（explain）：X是引用变量类型，它决定哪些方法可以调用；show（）和 show(Y y) 可以调用，而 show(int i)不可以调用。Y 是被引用对象的类型，它决定了调用谁的方法：调用 y 的方法。

Y 继承了 X，覆盖了 X 中的 show(Y y) 方法，但是没有覆盖 show() 方法。这个时候，引用类型为X的 x 指向的对象为 Y，这个时候，调用的方法由 Y 决定，会先从 Y 中寻找。执行 x.show(new Y());，该方法在 Y 中定义了，所以执行的是 Y 里面的方法；但是执行 x.show(); 的时候，有的人会说，Y 中没有这个方法啊？它好像是去父类中找该方法了，因为调用了 X 中的方法。事实上，Y 类中是有 show() 方法的，这个方法继承自 X，只不过没有覆盖该方法，所以没有在 Y 中明确写出来而已，看起来像是调用了 X 中的方法，实际上调用的还是 Y 中的。