【Java】封装、继承与多态详解！

继承

继承让我们更加容易实现类的扩展。子类是父类的拓展（extends）。

使用extends实现继承

public class Test{
public static void main(String[] args) {
Student s = new Student("123",123,"123");
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("学习");
}
public Student(String name,int height,String major) {
//天然拥有父类的属性
this.name = name;
this.height = height;
this.major = major;
}
}

上述的例子中Student类继承了Person类拥有Person的属性。

instanceof运算符

使用instanceof运算符能够判断一个对象是否属于某一个类，是则返回true，否则返回false。左边是判断对象，右边是类。

继承的特点

Java中只有单继承，没有像C++那样的多继承。多继承会引起混乱，使得继承链过于复杂，系统难于维护；

Java中类没有多继承，接口有多继承；

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

若一个类没有调用extends，则默认它的父类是：java.lang.Object.

object类

Object类是所有Java类的根基类，也就意味着所有的Java对象都拥有Object类的属性和方法。

to String方法Object类中定义有public String toString()方法，其返回值是 String 类型。toString()方法测试以及重写toString()方法

如：

class Person {
String name;
int age;
@Override
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);
}
}

结果：

info:李东，年龄:20;
cn.sxt.gao2.Test@15db972;

"=="和equals方法

"=="比较的是两者的地址，若地址相同则是同一对象；

Object类中定义有：public boolean equals(Object obj)方法，能够判断“对象内容相等”，Object 的 equals 方法默认就是比较两个对象的hashcode，是同一个对象的引用时返回 true 否则返回 false；

另外equals方法也能进行重写；

super关键字

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

若是构造方法的第一行代码没有显式的调用super(......)或者this(......)，那么Java默认都会调用super()，含义是调用父类的无参数构造方法。

public class Main {
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); //调用父类对象的成员变量
}
}

结果：

FatherClass.value=100
ChildClass.value=200
200
100

联系前面所学的静态初始化块时，会先上溯到object类，先执行object的静态初始化，再向下执行子类的静态初始化块，直到需要静态初始化的类为止。

封装

通过封装可以提高代码的安全性、复用性、便于调用； Java中4种“访问控制符”分别为private、default、protected、public；

• private 表示私有，只有自己类能访问；
• default表示没有修饰符修饰，只有同一个包的类能访问；
• protected表示可以被同一个包的类以及其他包中的子类访问；
• public表示可以被该项目的所有包中的所有类访问；

多态

多态是指方法的多态，与属性无关；

多态存在的条件：继承，方法重写，父类引用指向子类对象；父类引用调用子类重写的方法，多态出现。

对象的转型

对象的转型分为向上转型和向下转型；

向上转型属于自动转型是指父类指向子类对象，但向上转型后父类引用变量只能调用父类的方法不能调用子类的方法；

若想调用子类方法需要进行强制转换又被称作向下转型；

final关键字

修饰变量: 被final修饰的变量不可改变（常量）；

修饰方法：该方法不可被子类重写但是可以被重载；

修饰类: 修饰的类不能被继承；

抽象方法和抽象类

抽象方法

用abstract修饰的方法，没有具体的方法语句，只起一种声明的作用；

抽象类

包含抽象方法的类就叫抽象类，抽象类必须用abstract修饰，且必须被继承；

//抽象类
abstract class Animal {
abstract public void shout(); //抽象方法
}
class Dog extends Animal {
//子类必须实现父类的抽象方法，否则编译错误
public void shout() {
System.out.println("汪汪汪！");
}
public void seeDoor(){
System.out.println("看门中....");
}
}
//测试抽象类
public class TestAbstractClass {
public static void main(String[] args) {
Dog a = new Dog();
a.shout();
a.seeDoor();
}
}

注意： 抽象类不能实例化，即不能用new来实例化抽象类；

抽象类可以包含属性、方法、构造方法，但是构造方法不能用来new实例，只能用来被子类调用；

抽象方法必须被继承的子类实现；