面向对象

1 包
包是组织类的一种方式，保证类的唯一性。
如果代码中有相同的类，就会编译报错。这时可以放到不同的包中。
1.1 导入包中的类——Java提供了很多现成的类：

public class Test {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();//java.util包中的Date类
         System.out.println(date.getTime()); 
    }
}

或者写成import语句导入包

import java.util.Date;
public class Test {
    public static void main(String[] args) {
        Date date = new Date(); //更加简洁
        System.out.println(date.getTime());
    }
}

如果遇上要用多个java.util包中的类，可以写成：
import java.util.*
1.2 静态导入
使用import static导入包中的静态方法和字段，例如：

import static java.lang.Math.*;
public class Test {
    public static void main(String[] args) {
        double x = 30;
        double y = 40;
	// 静态导入的方式写起来更方便一些.
	// double result =  Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
	double result = sqrt(pow(x, 2) + pow(y, 2));
	System.out.println(result);
    }
}

1.3 包中的访问权限
当输入int a = 10；时，int前没有标明权限时，默认为default，只能访问在同一个包中的信息，无论在包中是否在同一个类里。

2 继承
为了方便代码调用。将公共代码放到一个单独的类中，让其他的类可以继承这个单独的类。这个单独的类里面包含的属性和方法，都自动被新的类支持进去。同时，新的类可以有自己独特的扩展。子类会继承父类所有的属性和方法。
2.1 基本语法
class 子类 extends 父类{
}
注意，一个子类只能继承一个父类。子类的实例中，也包含着父类的实例，可以使用super关键字得到父类实例的引用。
2.2 protected
继承中的封装，用portected关键字，无论是同一包中的子类还是不同包中的子类，都可以调用字段和方法。只有不同包的非子类才不能调用。
2.3 final
理论上可以无限制的继承下去，但一般不超过3，并且可以在最后一个子类加上final来表示该类无法再被继承。

3 多态
“一个引用，能表现出多种不同的形态”。当父类引用子类对象，并且父类和子类有同名覆盖的方法，这时，如果通过父类引用调用这个重名方法，就会发生动态绑定。封装是为了不让调用者知道类的实现细节（但还是知道是个啥类），多态更进一步，只要知道有某个方法就行。
3.1 向上转型
一个父类的引用指向一个子类的实例。例如：

class Animal{  //Animal父类 
    protected String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(String food){
        System.out.println("我是一只小动物");
        System.out.println(this.name + "吃" + food);
    }
}
class Bird extends Animal{ //Bird子类
    public Bird(String name) { //继承父类属性
        super(name);
    }
    public void eat(String food){ //重写父类方法
        System.out.println("我是一只小鸟");
        System.out.println(this.name + "正在吃" + food);
    }
    public void fly(){  //子类特有方法
        System.out.println(this.name + "正在飞");
    }
}
public class test1 { //向上转型1
    public static void main(String[] args) {
        Animal bird = new Bird("小小鸟"); //直接赋值，父类引用指向子类实例，在这里发生向上转型
	bird.eat("谷子"); //父类必须有eat方法 ，发生动态绑定，重写父类eat方法
    }
}

运行结果为：
我是一只小鸟
小小鸟正在吃谷子

public class test2 { //向上转型2
    public static void main(String[] args) {
        Bird bird = new Bird("小小鸟");
        feed(bird); //方法传参
    }
    public static void feed(Animal animal){
        animal.eat("谷子");
    }
}

运行结果为：
我是一只小鸟
小小鸟正在吃谷子

public class test3 { //向上转型3
    public static void main(String[] args) {
        Animal animal = findMyAnimal();//方法返回
        animal.eat("小米");
    }
    public static Animal findMyAnimal(){
        Bird bird = new Bird("圆圆");
        return bird;
    }
}

运行结果为：
我是一只小鸟
圆圆正在吃小米
3.2 动态绑定
子类与父类中同时出现同名的方法，具体执行时调用哪个方法，就要看这个引用指向的是父类对象还是子类对象，这个过程是程序运行时决定的（不是编译期），因此成为动态绑定。test1中有所体现。
3.3方法重写
重写也可以叫覆写/覆盖（Override）。与重载不同。重写中子类的方法访问权限不能低于父类的访问权限。针对重写，可以用@Override来显示指定。

class Shape{ //父类
    public void draw(){ //父类方法
    }
}
class Cycle extends Shape{
    @Override //重写
    public void draw() {
        System.out.println("⚪");
    }
}
class Triangle extends Shape{
    @Override
    public void draw() {
        System.out.println("▲");
    }
}
class Flower extends Shape{
    @Override
    public void draw() {
        System.out.println("❀");
    }
}

public class test1 {
    public static void main(String[] args) {
        Shape shape1 = new Flower();
        Shape shape2 = new Cycle();
        Shape shape3 = new Triangle();
        drawShape(shape1);
        drawShape(shape2);
        drawShape(shape3);
    }
    public static void drawShape(Shape shape){
        shape.draw();
    }
}

最终结果为打印出三种形状。
使用多态的好处
（1）类的调用者对类的使用成本降低
（2）避免大量的if-else，降低全复杂度
（3）如需新增，改动成本低
3.4 向下转型
将父类的对象转为子类的对象

public static void main(String[] args) {
    Animal animal = new Bird("圆圆");
    animal.eat("谷子");
    //animal.fly(); //错误
    ((Bird) animal).fly(); //强转成Bird型，但不能转成Cat型
    //因为new出的是bird实例

编译过程中，animal的类型是Animal，因此，编译器只知道有一个eat方法，没有fly方法，虽然animal指向一个Bird对象，，但编译器是以animal的类型来查找方法。对于Animal animal = new Bird(“name”)这样的代码：（1）编译器检测有哪些方法的存在，只看Animal这个类型；（2）执行时到底执行父类还是子类，看的是Bird这个类型。

Animal animal1 = new Bird("扁扁");
    if (animal1 instanceof Bird) { //always true
        Bird bird = (Bird) animal1;
        bird.fly();
    }
    System.out.println("=============");
    Animal animal2 = new Cat("小猫");
    if(animal2 instanceof Bird){ //always false
        Bird bird1 = (Bird) animal2;
        bird1.fly();
    } // 不执行，new出的Cat实例，不是Bird
    System.out.println("-----------");
}

instanceof可以判定一个引用是否是某个类的实例，是就返回true，执行if中的语句。

4 抽象类
在3.3中父类Shape中的draw方法没有实际工作，绘制方法都是由子类的draw方法实现。这样的父类可以设计成一个抽象方法，包含抽象方法的类就被成为抽象类。

abstract class Shape{
    abstract public void draw();
}

draw方法前加上abstract关键字，表示这是一个抽象方法，同时抽象方法没有方法体（没有{}，不能有具体执行的代码）对于包含抽象方法的类，必须加上abstract关键字表示这是一个抽象类。
注意：（1）抽象类不能直接实例化。
//Shape shape = new Shape(); //编译出错（2）抽象方法不能是private（3）抽象类中可以包含其他非抽象方法。

abstract  class Shape2{ //抽象类
    abstract public void draw(); //抽象方法，想要使用必须构建子类并在其中重写
    void func(){  //非抽象方法
        System.out.println("func()");
    }
}
class Rect extends Shape2{
    @Override
    public void draw() { //实现（重写）抽象方法
        System.out.println("draw(Rect)");
    }
}
public class test8 {
    public static void main(String[] args) {
        Shape2 shape2 = new Rect(); //向上转型
        shape2.func(); //非抽象
        shape2.draw(); //抽象
    }
}

运行结果：
func()
draw(Rect)
抽象类本身不能被实例化，要想使用，只能创建抽象类的子类，让子类重写抽象类中的抽象方法。

5 接口
接口是类的更进一步，抽象类中还可以包含非抽象方法，但接口中的方法都是抽象方法。字段只能包含静态常量。

interface IShape{
    public abstract void draw(); //public abstract可以省略
    public static final int num = 10; //public static final可以省略
}
class Cycle implements IShape{
    @Override
    public void draw() { //public不能省略
        System.out.println("⚪");
    }
}
public class test6 {
    public static void main(String[] args) {
        IShape shape = new Cycle();
        shape.draw();
    }
}

使用interface定义一个接口；方法一定是抽象的，可以省略abstract；方法一定是public的，可以省略public；Cycle用implements继承接口；调用时可以创建一个接口的引用，对应到一个子类的实例。接口不能被单独实例化。
在Java中只支持单继承，一个类只能extends一个父类，但可以同时实现多个接口，也能到达多继承类似的效果。

class Animal1{ //父类
    private String name;
    public Animal1(String name){
        this.name = name;
    }
}
interface IFlying{ //接口
    void fly();
}
interface IRunning{
    void run();
}
interface ISwimming{
    void swim();
}

class Cat1 extends Animal implements IRunning{ // 先继承 再接口
    public Cat1(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(this.name + "正在用四条腿跑");
    }
}
class Fish extends Animal implements ISwimming{
    public Fish(String name) {
        super(name);
    }
    @Override
    public void swim() {
        System.out.println(this.name + "用尾巴游泳");
    }
}
class Frog extends Animal implements IRunning, ISwimming{
    public Frog(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(this.name + "往前跳");
    }
    @Override
    public void swim() {
        System.out.println(this.name + "用腿游泳");
    }
}
class Robot implements IRunning{ //不用继承也可以实现接口
    private String name;
    protected Robot(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        System.out.println(this.name + "用轮子跑");
    }
}
public class test7 {
    public static void main(String[] args) {
        Cat1 cat = new Cat1("小猫");
        walk(cat);
        Frog frog = new Frog("小青蛙");
        walk(frog);
        Robot robot = new Robot("机器");
        walk(robot);
    }
    public static void walk(IRunning running){
        System.out.println("去散步");
        running.run();
    }
}

接口之间也可以实现继承，甚至是多继承

interface IRunning{
    void run();
}
interface ISwimming{
    void swim();
}
interface IAmphibious extends IRunning,ISwimming{ //接口继承多个接口（extends）
}
class Frog implements IAmphibious{
//类和接口之间是实现（implements）
}

学生成绩排序

import java.util.Arrays;
class Student implements Comparable{
    private String name;
    private int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }
    @Override
    public String toString(){
        return "[" + this.name + ":" + this.score + "]";
    }
    @Override
    public int compareTo(Object o) {
        Student s = (Student)o;
        if (this.score > s.score){
            return -1;
        }else if(this.score < s.score){
            return 1;
        }else{
            return 0;
        }
    }
}
public class test{
    public static void main(String[] args) {
        Student[] students = new Student[]{
                new Student("zhangsan",95),
                new Student("lisi",96),
                new Student("wangwu",97),
                new Student("zhaoliu",92),
        };
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

附1 权限之间的区别

附2 重载与重写

附3 抽象类与接口