面向对象编程（java）基本语法

包

包是组织类的一直种方式，使用包的主要目的是保证类的唯一性。
一般情况下导入包的时候可以在class前加如下语句

import java.long.Math

也可以有这样的导入方法

java.util.Data data = new java.util.Data()

继承

关键字：extends
语法：class 子类 extends 父类
继承后子类拥有父类的所有属性（包括private声名的 字段，只是子类没有访问这类字段的权限）
ex：

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);     } 
}

这里我们想保证java的封装，就可以用protected关键字来声名父类的字段，这样既保证了封装又可以让子类访问父类的字段。
这里我给出java中四个关键字的访问权限：

注意：java中只能单继承不能多继承，且建议最多继承三次，即 A extends , B extends C, C extends D ,这里的A 就不要有子类了。我们可以用final修饰A，表示A不能被继承

final class A extends B {}

在子类中可以用super方法调用父类对象，父类对象有带参数的构造方法时，子类在继承的时候需要先帮父类进行构造

class A {
    public String name;

    public A(String name) {
        this.name = name;
    }
}
class B extends A {
    public B(String name) {
        super(name);
    }
}

组合

语法格式：

public class Student {     ... } 
 
public class Teacher {     ... } 
 
public class School {
 public Student[]students;    
 public Teacher[] teachers; } 

即组合类的属性是两个类，没有别的属性。

多态

什么是多态？
多态是面向对象语言的一个特点，他可以通过父类引用引用子类方法，从而调用子类中的重写方法。

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("□");  
     } 
     } 
 
class Flower extends Shape {   
  @Override    
   public void draw() {    
        System.out.println("♣");     }
 } 

这里我们就可以定义这样的方法直接打印三个不停对象的draw方法了

public static void drawShapes() {    
 // 我们创建了一个 Shape 对象的数组.  
     Shape[] shapes = {new Cycle(), new Rect(), new Cycle(), new Rect(), new Flower()}; 
         for (Shape shape : shapes) {  
                shape.draw();    
          }
 } 

这里其实发生了向上转型 和动态绑定
向上转型：父类引用 引用子类对象
表现形式：
1.方法穿参
2.直接赋值（上面我们用了直接赋值）
3.返回值
动态绑定：先发生了向上转型，且父类和子类中用方法被重写，然后通过父类引用调用重写的方法。这时调用的是子类的方法。