java 面向对象编程（继承、多态）

包（package）

包是组织类的一种方式，使用包的主要目的是保证类的唯一性。

导入包中的类

一、

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

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

//使用java中的类就可以有如下写法：
java.util.*   
//但还是建议要加上导入的类名，否则容易冲突。

二、导入包中的静态方法和字段
使用import static
eg:import static java.lang.*;
三、将类放到包中

• 在文件的最上方加入package语句，来指定此代码在哪个包中。
• 包名要和代码路径相匹配，如果创建的包是com.demo,则会有一个相对应的路径com/demo,用来存储代码。
• 如果一个类中没有package语句，那么这个类就会被放进一和默认包中。
  四、包访问权限控制

public : 公开的，public 修饰的字段和方法对所有的用户开放，即类内部和类的调用者都能访问。
private： 私有的，private 修饰的字段和方法只能被类的内部使用
默认default(也叫包访问权限)： 类内部、同一个包的类都可访问，其他类不能
protected: **类内部能访问，一个类的子类和同一个包的类可以访问 ，其他类不能访问。

继承

基本语法
class 父类  extents 父类{

}

使用extends指定父类；
java中一个子类只能继承一个父类（所以java是一门单继承的语言）；
子类继承的是父类的所有public 的字段和方法；
对于父类private修饰的字段和方法，子类时无法访问的。

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{   //让Cat继承Animal类
    public Cat(String name){
        super(name);  //super调用父类的构造方法
    }
}

class Bird extends Animal{   //让Bird继承Animal类
    public Bird(String name){
        super(name);
    }

    public void fly(){
        System.out.println(this.name+"正在飞");
    }
}
public class TestDemo1 {
    public static void main(String[] args) {

        Cat cat = new Cat("小花");
        cat.eat("猫粮");
        Bird bird = new Bird("小明");
        bird.fly();



输出结果：小花正在吃猫粮
        小明正在飞

final

final关键字，修饰一个变量和字段的时候，表示常量（不能修改），功能是限制类被继承。

多态

向上转型

子类对象赋值给父类称为向上转型（或父类引用子类对象）

Bird bird = new bird("小花");
//也可以写成下面形式
Bird bird = new bird("小花");
Animal animal = bird;
//或者下面形式
Animal animal = new cat("小花"）;
//animal是父类的引用，指向一个子类Bird的实例。

向上转型发生的时机：直接赋值；方法传参；方法返回。

向下转型

if(animal   instance  of  bird){//首先要判断bird是否是animal的实例
    Bird  brid = (Bird) animal;//需要强制类型转化
    bird.fly();
}
//（Bird）表示强制类型转换；

向下转型的条件：父类已经引用了子类（向下转型后的类型）的对象
向下转型就是父类对象转成子类对象，相对于向上转型，向下转型不太常见。

动态绑定

public class Test { 
 public static void main(String[] args) { 
 Animal animal1 = new Animal("小花"); 
 animal1.eat("谷子"); 
 Animal animal2 = new Bird("小明"); 
 animal2.eat("谷子"); 
 } 
}
//animal1 和 animal2 虽然都是 Animal 类型的引用, 但是 animal1 指向 Animal 类型的实例, animal2 指向Bird 类型的实例.
//针对 animal1 和 animal2 分别调用 eat 方法, 发现 animal1.eat() 实际调用了父类的方法, 而animal2.eat()实际调用了子类的方法。

因此, 在 Java 中, 调用某个类的方法, 究竟执行的是父类方法的代码还是子类方法的代码 , 要看究竟这个引用指向的是父类对象还是子类对象. 这个过程是程序运行时决定的(而不是编译期), 因此称为 动态绑定.

发生运行时绑定（动态绑定）的条件：1.先要向上转型（父类的引用引用子类的对象）2.父类和子类都有同名的覆盖方法（此方法之间的关系就是重写）

方法重写

对于上面动态绑定中的代码中，对eat方法来说，子类实现了父类的同名方法，并且参数类型和个数完全相同，所以称为覆写/重写/覆盖（Override）

重写的规则：
普通方法可以重写，static修饰的静态方法不能重写。
重写中子类的方法的访问权限不能低于父类的方法访问权限

多态

class Shape { 
 public void draw() { 
 } 
} 
class Cycle extends Shape { 
 @Override 
 public void draw() { 
 System.out.println("○"); 
 } 
} 
class Rect extends Shape { 
 @Override 
 public void draw() { 
 System.out.println("□"); 
 } 
}

// Test.java 
public class Test { 
 public static void main(String[] args) { 
 Shape shape1 = new Cycle(); 
 Shape shape2 = new Rect(); 
 drawMap(shape1); 
 drawMap(shape2); 
 } 
 // 打印单个图形
 public static void drawShape(Shape shape) { 
 shape.draw(); 
 } 
}

当类的调用者在编写 drawMap 这个方法的时候,参数类型为 Shape (父类), 此时在该方法内部并不知道, 也不关注当前的 shape 引用指向的是哪个类型(哪个子类)的实例.

此时 shape 这个引用调用 draw 方法可能会有多种不同的表现(和 shape 对应的实例相关)，这种行为就称为多态。

抽象的抽象类

abstract class Shape{//对于包含抽象方法的类，必须加上abstract表示这是一个抽象类
	abstract public void draw();//这是一个抽象方法，没有方法体。
}

1.抽象类不能实例化；
2.抽象方法不能是private的；
3.抽象类中可以包含其他非抽象方法，也可以包含字段。这个非抽象方法同普通方法，可以被重写，可以被子类直接调用。

作用

抽象类存在的最大意义就是为了被继承

抽象类本身不能被实例化，如果要使用，只能创建该抽象类的子类，再让子类重写抽象类中的抽象方法。

接口

接口包含的方法都是抽象方法，字段只能包含静态常量。

interface IShape {//使用interface定义一个接口
 void draw();     //接口的方法一定是public abstract，因此可以省略
} 
class Cycle implements IShape { //Cycle使用implements继承接口.此时表达的含义是 "实现"
 @Override 
 public void draw() { 
 System.out.println("○"); 
 } 
} 
public class Test { 
 public static void main(String[] args) { 
 IShape shape = new Rect(); 
 shape.draw(); 
 } 
}

接口中只能包含抽象方法，对于字段，接口中只能包含静态变量（final static）

interface IShape { 
 void draw(); 
 public static final int num = 10; 
}

1. 我们创建接口的时候, 接口的命名一般以大写字母 I 开头.
2. 接口的命名一般使用 “形容词” 词性的单词.
3. 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号