面向对象的三大特征

1.封装
2.继承
3.多态

封装注意点：

1.封装就是将抽象的数据组装起来,构成class类.

2.属性需要定义在类中，又叫做成员变量； 而定义在方法中的变量叫做局部变量。

3.局部变量使用前必须要声明并赋初值；成员变量使用前必须要声明，但可以不赋初值。

4.成员变量与局部变量的联系与区别：
a) 无论是成员变量还是局部变量，使用前都需要声明（定义）。
b) 对于局部变量来说，使用前必须要初始化；对于成员变量来说，使用前可以不初 始化。如果没有初始化成员变量就开始使用，那么每个类型的成员变量都有一个 默认的初始值
i. byte、short、int、long 类型的初始值为 0
ii. float、double 类型的初始值为 0.0
iii. char 类型的初始值‘\u0000’
iv. boolean 类型的初始值为 false

5.如果一个类包含了属性与方法，那么该类的每一个对象都具有自己的属性，但无论一个 类有多少个对象，这些对象共享同一个方法(放在代码区)。

6.关于方法参数传递的总结：对于 Java 中的方法参数传递，无论传递的是原生数据类型 还是引用类型，统一是传值（pass by value）。

7.什么类型的引用就能指向什么类型的对象，比如 People 类型的引用就能指向 People 类 型的对象，但不能指向 Student 类型的对象。比如：

 People people = new People(); // 正确
 People people = new Student(); //错误  

8.构造方法（Constructor） ：构造方法用于完成对象属性的初始化工作，构造方法的特点：
a) 构造方法的名字必须与类名完全一致（包含大小写）
b) 构造方法没有返回值，连 void 也不能出现。
c) 如果在定义一个类的时候，没有为类声明构造方法，那么 Java 编译器会自动为类 添加一个没有参数且方法体为空的构造方法（默认的构造方法）
d) 如果在定义一个类的时候，为类声明了构造方法，那么 Java 编译器就不会再为类 添加构造方法了。
e) 不能显式调用类的构造方法，构造方法通常是通过 new 关键字隐式调用。

public class People {
    public String name;
    public int  age;
    People(String name,int age){
        this(name);//构造方法之间的调用，只能写在构造方法第一行，普通的方法重写的调用父类的没有这个限制
        this.age = age;
    }
    People(String name){
        this.name = name;
    }
    public static void main(String[] arges){
        People  p=new People("elese",26);
        System.out.println(p.name);
        System.out.println("test");
    }
}

9.new 关键字在生成对象时完成了三件事情：
a) 为对象开辟内存空间。
b) 调用类的构造方法。
c) 将生成的对象的地址返回。

10.默认的构造方法：构造方法没有参数且方法体为空。

11.使用 new 来生成对象的时候，后面的小括号()表示构造方法的参数列表，如果构造方法 不接收参数，那么小括号中的内容为空；如果构造方法接收参数，那么小括号中的实际 参数就需要与构造方法定义中的形式参数保持一致（参数数量一致、参数类型一致、按 照顺序逐一赋值）。

12.方法重载
a).方法名字相同，参数个数和类型不同的方法叫重载。返回值没有影响

public void change(int a,int b){
       System.out.println("int change");
   }
   public void change(int a,int b,int c){
       System.out.println("int3 change");
   }
   public int change(int a,float b){
       System.out.println("float change");
       return 2;
   }
这三个方法都是重载方法

继承

public class test {

    public static void main(String[] args) {
          System.out.print(new Apple(2.3).price);
    }

}

class Fruit{
    public double price;
    Fruit(){
        System.out.println("Fruit");
    }
    Fruit(double price){
        System.out.println("Fruit price");
        this.price = price;
    }
}
class Apple extends Fruit{
    Apple(double price) {
        super(price);//和this一样，必须填写在第一行
        System.out.println("apple");
        this.price = 2.4;
    }
}
输出结果：
Fruit price
apple
2.4

继承注意点

1.当一个类没有构造方法的时候，系统会默认添加一个无参构造方法。如果有构造方法，系统将不会添加构造方法
2.构造方法之间的关系必定的方法的重载
3.继承后，子类的构造方法中如果没有显示调用父类的构造方法，将隐士调用父类的无参构造方法（如果某种原因不存在）将会编译出错
4.子类显示调用父类构造方法的时候super必须写在构造方法的第一行
13.方法重写，发生在子类与父类之际

多态

定义：子类就是父类（玫瑰花是花，男人是人），多态的意思就是：父类引用指向子类对象。（说白了就是父类引用指向子类对象的时候编译器让你编译通过而已。向上转型。如果向下转型编译器不让通过而已，强制转换就可以蒙混编译器）

public class test {

 public static void main(String[] args) {
  //多态，向上转型(就是保证了，转型后调用的不会出错)
  Fruit f = new Apple();
  f.getColor();
  //向下转型（swift的概念，这个概念能成功的依据就是保证向下转型的对象本身就是能转型成这个的对象，如果向下转型的对象，不是期望转型的对象就会出错）
  Object o = new Apple();
  Apple a = (Apple)o;
  a.getColor();
 }

}

class Fruit{
 public void getColor(){
  System.out.println("getColor");
 }
}
class Apple extends Fruit{
 public void getPrice(){
  System.out.println("getPrice");
 }
}

抽象类

// 抽象类
abstract class AbstractTest{
 int a;
 void go(){
  
 }
 abstract void run(); //抽象方法
}

warning：
1.具有抽象方法的类，称为抽象类
2.抽象类不能是实例化，只能用于继承
3.有抽象方法之说，没有抽象属性之说，其他的和普通类无异
4.子类继承抽象类，子类必须实现抽象类中的所有抽象方法，否则就将子类定义为抽象方法

接口（interface）

//接口的定义，因为类只能继承一个，那么接口就运用而生，一个类可以实现多个接口
interface run{
 static final String str = "liyang";
 int a = 0; //默认的都是static final的
 void fun(); //默认的都是抽象方法，可以省略abstract
}

static 关键字

public class test {
   public static void main(String[] args) {
    animal.run();   //类直接调用
    new animal().run(); //对象直接调用
   animal a = null;
    a.run(); // 输出为lilei,那么可以推断静态方法和静态属性都是根据引用类型来调用的
   }
}
class animal {
   static String name =  "lilei"; //类属性，所有类对象共有，放在静态常量区，而非堆栈区
   static void run(){    //类方法（里面只能访问类属性）
      System.out.println(name); 
   }
}
warning:静态方法只能被继承不能被重写

1.静态代码块

public class test {
 public static void main(String[] args) {
   new P();
   new P();
 }
}
class P{
 int c =getC();
 static int a=getA();
 static {
  System.out.println("static Code");
 }
 static int b=getB();
 static int getA(){
  System.out.println("getA");
  return 2;
 }
 
 static int getB(){
  System.out.println("getB");
  return 2;
 }
 
 int getC(){
  System.out.println("getC");
  return 2;
 }
 P(){
  System.out.println("P Constructor");
 }
}
输出结果：
getA
static Code
getB
getC
P Constructor
getC
P Constructor
总结：
1.java文件先被编译成class文件，切java文件和class文件不是一一对应的，一个java文件可以对应N个class，一个class文件代表一个类
2.类（class）在被使用的时候，首先将class文件加载到JVM虚拟机，执行将该类的静态变量初始化和执行静态代码块，切执行顺序是从上到下执行，只会在被加载的时候执行一次

3.成员变量的初始化会优先于构造方法的初始化，没有给值就是默认值，从getC()可以看出
4.执行构造方法，构造方法中，再将其修改为指定的值，这是惯用手法

final关键字

• final可以修饰类，属性和方法
  1.修饰类，类就不可被继承
  2.修饰属性，属性就不可被修改，相当于常量
  a).声明的时候赋值
  b).构造方法里赋值
  3.修饰方法，那么方法就不能被重写

访问修饰符

• 简述：
  1.public （任何地方都可以使用）
  2.protected（受保护的，可以在子类中使用）
  3.private(私有的，只有在该类内部使用)
  4.default(不加任何修饰符，就是包权限，只能在相同包下类似public的权限)