Java~面向对象编程的包、继承、组合、多态

包：
包是组织类的一种方式
使用包的目的就是为了保证类的唯一性。
将类放入包中，需在文件上方加package，包名一般指定唯一名字。

public class Test {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
   }
}

import java.util.Date;
public class Test {
    public static void main(String[] args) {
        Date date = new Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
   }
}

default
包的访问权限default，顾名思义只要在同一个包内便可使用。

protected：
类访问权限protected，对于类的调用者来说不能访问。但对于子类和同一包的其他类来说可以访问。

继承：
使用extends指定父类（基类、超类）
Java中一个子类（派生类）只能有一个父类
子类继承父类除构造函数以外的所有东西
对于父类的private修饰的字段，子类无法直接访问，但可以使用super关键字得到父类的字段
如果子类要实例化必须先实例化父类，就是说用子类的构造函数必须先调用父类的构造函数

class Animal {
    public String name;
    public Animal(String name) {
        this.name = name;
   }
    public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
   }
}
class Cat extends Animal {
    public Cat(String name) {
        // 使用 super 调用父类的构造方法. 
        super(name);
   }
}
class Bird extends Animal {
    public Bird(String name) {
     super(name);
   }
    public void fly() {
        System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
   }
}
public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat("小黑");
        cat.eat("猫粮");
        Bird bird = new Bird("圆圆");
        bird.fly();
   }
}

super：（父类对象的引用）
super（）表示调用父类的构造函数
super.data表示调用父类的属性
super.fun（）表示调用父类的方法

final：
final修饰变量，使变量变成常量
final修饰类，叫做密封类，不能直接被继承
final修饰方法，不可被重写

组合：
继承就是 XX is a YY
组合就是 XX has a YY

向上转型：
父类引用子类对象
方式：
直接赋值
方法传参
方法返回值
但要注意：通过父类引用，只能引用父类自己的方法和属性

public class Test { 
 public static void main(String[] args) { 
 Bird bird = new Bird("圆圆"); 
 feed(bird); 
 } 
 public static void feed(Animal animal) { 
 animal.eat("谷子"); 
 } 
} 
// 执行结果
圆圆正在吃谷子

public class Test { 
 public static void main(String[] args) { 
 Animal animal = findMyAnimal(); 
 } 
 public static Animal findMyAnimal() { 
 Bird bird = new Bird("圆圆"); 
 return bird; 
 } 
}

向下转型：
使用向下转型不安全，因为要发生向下转型就必须发生过向上转型。

方法重写（override）：
重写与重载不同的是重写三个要求（方法名、参数列表、返回值）都得相同，而且重写是在继承关系上

注意：
要重写方法访问修饰符不可使为private
访问修饰限定符不一定要相同，但是一定要满足子类的访问权限要大于等于父类的访问权限
静态方法不可被重写

多态：
也叫运行时绑定、动态绑定
前提:
发生向上转型父类引用子类对象，子类和父类有同名的覆盖方法通过父类的引用调用该重写方法时便会发生动态绑定
构造函数当中也可以发生动态绑定

Java~面向对象编程的包、继承、组合、多态

猜你喜欢