面向对象封装，继承，super关键字，重写

使用访问控制符，实现封装
    成员（成员变量或成员方法）访问权限共有四种： 
        public 公共的  

                可以被项目中所有的类访问。(项目可见性) 
        protected 受保护的  

                 可以被这个类本身访问；同一个包中的所有其他的类访问；被它的子类（同一个包以及不同包中的子类）访问
        default／friendly 默认的/友好的（包可见性）  

                   被这个类本身访问；被同一个包中的类访问。
        private 私有的  

                   只能被这个类本身访问。（类可见性）

类的访问权限只有两种
        public 公共的  

                   可被同一项目中所有的类访问。 (必须不文件名同名) 
        default／friendly 默认的/友好的  

                    可被同一个包中的类访问。

封装要点:
    类的属性的处理:
           1.一般使用private. (除非本属性确定会让子类继承)
           2.提供相应的get/set方法来访问相关属性. 这些方法通常是public,
        从而提供对属性的读取操作。 （注意：boolean变量的get方法是用：is开头!） 
    一些只用于本类的辅助性方法可以用private，希望其他类调用的方法用public

总结
    方法调用中的参数传递（重中之重） 
           基本数据类型的参数传递：不能改变参数的值
           引用数据类型的参数传递：不能改变参数的值
this
      This代表当前对象自身的引用（必须new） – This可以修饰属性，区别成员变量和局部变量
      This修饰方法
      This修饰构造方法（必须是第一条语句） 
static
       static变量：只有一份，属于类，可以类名. Static变量
       static方法: 类名. Static方法，不能出现this和super
       static代码块：只执行一次，最早执行的（类第一次调用） 
  package import
         包：作用
         导入：import com.bjsxt.oop.*;
         静态导入： import static java.lang.Math.PI;
 

继承：
    类是对对象的抽象，继承是对某一批类的抽象，从而实现对现实世界更好的建模。 
    提高代码的复用性！ 
    extands的意思是“扩展”。子类是父类的扩展
    不同的叫法：超类、父类、基类、子类、派生类

   表示父类跟子类之间的关系
   当两个类或者多个类具备相同的属性和方法的时候，可以提取出来，变成父类，子类可以继承

   子类跟父类是is-a的关系

   使用：
       1、使用继承的时候需要使用extends关键字
       2、使用继承关系之后，父类中的属性和方法都可以在子类中进行使用(非私有属性和非私有方法)
       3、java中是单继承关系(如果包含多个父类，同时父类中包含重名方法，无法决定该调用谁)

public class TestExtends {
    public static void main(String[] args) {
        Mammal m1 = new Mammal();
        m1.puru();
        m1.eat();
    }
}

class Animal{
    String eyes = "眼睛";
    String name = "无名";
    public void eat(){
        System.out.println("动物吃东西！");
    }
}

class Mammal extends Animal{
    public void puru(){
        eyes = "嘴巴";
        System.out.println("小动物吃奶！");
    }
}

 super:是 直接父类 对象的引用
   用途：
       1、可以在子类中调用父类中被子类覆盖的方法  super.父类方法名称
       2、当super在普通方法中使用的话，可以任意位置编写
       3、当super在构造方法中使用的话，会调用父类的构造方法，一定要将super放在第一行
       4、在构造方法中super关键字和this关键字(指的是不能同时使用this关键字调用重载的构造方法)不能同时出现
       5、父类中私有的属性和方法都不能被调用，包括构造方法
       6、子类的构造方法中都会默认使用super关键字调用父类的无参构造方法,因此在定义类的时候，无论自己是否自定义了
               其他构造方法，最好将无参构造方法写上
       7、如果构造方法中显式的指定了super的构造方法，那么无参的构造方法就不会被调用

   总结：
       1、在创建子类对象的时候一定会优先创建父类对象
       2、所有的java类都具备同一个顶级父类（老祖宗），称之为Object，是所有类的根类

public class Test {
    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);
    }
}

 重写：(覆盖)override
   必须要存在继承关系，当父类中的方法无法满足子类需求的时候可以选择使用重写的方式
   注意：
       1、重写表示的是子类覆盖父类的方法，当覆盖之后，调用同样的方法的时候会优先调用子类
       2、重写的方法名称，返回值类型，参数列表必须跟父类一致
       3、子类重写的方法不允许比父类的方法具备更小的访问权限
           父类      public     子类  public
           父类      protected   子类  public protected
           父类      default       子类  public protected  default
   父类的静态方法子类可以进行调用，但是子类不可以重写(但是可以继承)

public class TestOverride {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Animal2.shout();
        Dog dog = new Dog();
        dog.shout();
    } }
class Animal2{
    static void shout(){
        System.out.println("发出声音！");
    }
}
class Dog extends Animal {
    static void shout(){
        System.out.println("旺旺旺！");
    }
}