访问修饰符有private、protected、public。

私有变量和私有方法（private）

有一个A类，他的成员变量和方法都是私有

public class A {
    private int a;
    private int sum (int m,int n){
        return m - n;
    }
}

那么对于另一个B类，在其中创建一个A类的对象，该对象是不能访问自己的私有变量和方法的。

公有变量和公有方法（public）

有一个A类，他的成员变量和方法都是公有的。

public class A {
    public int a;
    public int sum (int m,int n){
        return m + n;
    }
}

那么在任何一个类B中创建其对象后他的变量和方法都可以被访问到

友好变量和友好方法（默认）

public class B{
    int a;
    int sum(int m,int n){
        return m + n;
    }
}

这种情况需要在同一个包中，就是类A和类B在同一个package下

受保护变量和受保护方法（protected）

同友好变量和友好方法的访问权限一样

public类和友好类

在声明类的时候，如果在关键字class前面加上public关键字，那么他就是共有类，可以在任意一个类中使用public类创建的对象，

友好类就需要在同一个package下。

继承

声明格式

修饰符 class 子类名字 extends 父类名{
}

修饰符可以是public abstract final

继承的使用原则

1.子类能够继承父类中被声明为public和protected的成员变量和方法，但不能继承父类中被声明为private的成员变量和方法。

2.子类能继承在同一个包中由默认修饰符的成员变量和成员方法。

3.如果子类声明了一个与父类的成员变量同名的成员变量，则子类不能继承父类的成员变量。

4.同3，如果方法名相同时候子类不能继承父类方法。

对于3和4的理解：

public class Bird extends Animal{}

一切以bird为准就是对3和4的理解。如果bird和animal同时写了这些就以bird为准

如果还想重名也用父类的成员变量和方法就需要super

super

super和this可以理解为一个指针，super这个指针指向离自己最近的父类

this指向自己类本身的一个指针

class Country {
    String name;
    void value() {
       name = "China";
    }
}
  
class City extends Country {
    String name;
    void value() {
    name = "Shanghai";
    super.value();      //调用父类的方法
    System.out.println(name);
    System.out.println(super.name);
    }
  
    public static void main(String[] args) {
       City c=new City();
       c.value();
       }
}

运行结果：

Shanghai
China

子类的继承

1.同一个包中的子类与父类，子类可以继承父类中非private修饰的成员变量和方法。

2.不在同一个包内的子类和父类，子类可以继承被public和protected修饰的成员变量和方法。

多态：一个重载和重写

重载：两同一不同：同一类，相同的名字。参数列表不同

重写：放生在继承，子类覆盖父类，以父类为准

方法覆盖发生在继承里，子类根据需要重写继承的方法。
目的：用父类的方法名重写了一个新的方法
发生在运行阶段
需要覆盖的方法要和父类方法具有完全相同的方法名，返回值，参数列表（个数、类型、顺序）。

重写/覆盖需要注意：

子类不能覆盖父类中声明为final和static的方法。

子类必须覆盖父类中声明为abstract的方法，或者子类也将该方法声明为abstract。

覆盖双方的声明应该是一致的

抽象类和抽象方法 abstract

       为什么需要有抽象这个概念，某些类一定需要模型方法才能启用，把这个方法抽象后，要想实例化要么重写这个方法，要么继续abstract它。这样就避免子类的随意设计。

抽象方法不能用private和static修饰，因为抽象方法需要被重写，只有可以访问且可以修改才可以完成这个流程。

一、什么是抽象类
       在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

二、为什么要用抽象类
老是在想为什么要引用抽象类，一般类不就够用了吗。一般类里定义的方法，子类也可以覆盖，没必要定义成抽象的啊。

其实不是说抽象类有什么用，一般类确实也能满足应用，但是现实中确实有些父类中的方法确实没有必要写，因为各个子类中的这个方法肯定会有不同，所以没有必要再父类里写。当然你也可以把抽象类都写成非抽象类，但是这样没有必要。

而写成抽象类，这样别人看到你的代码，或你看到别人的代码，你就会注意抽象方法，而知道这个方法是在子类中实现的，所以，有个提示作用。

内部类：

public class A{}中，{}还可以定义类，这种类叫做内部类，

内部类分为四种：成员内部类、局部内部类、静态内部类、匿名类（不能用public修饰）

成员内部类就是并架于成员变量的类

调用较为复杂些：

public class Sample{
    public int id;
    class Inner{

    }     
}

//调用格式
Sample sample = new Sample();
Sample.Inner inner = sample.new Inner();

局部内部类(方法中的类)

public void sell(){
    class Apple{
    }
}

静态内部类 static

就是共享类。

匿名类

//声明
new 类名字(){}

内部类很多还需要继续学习！后续一点点再补齐