面向对象的三大特征--继承、多态、封装

一、封装(encapsulation)

含义：
封装就是将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，以特定的访问权限来使用类的成员。
将属性私有化（private关键字修饰），需要提供对应接口完成设置和访问（公开的setter和getter方法）。

class Cat{
    //私有化属性
	private int id;
	//获取私有化属性的方法
	public int getId(){
	   return this.id;
	}
	//设置私有化的属性
	public void setId(int id){
	   this.id=id;
	}
}

POJO对象：标准的Java bean对象(经典的Java bean对象)
根据封装来写
私有化属性
提供公开的setter和getter方法

私有化构造函数：
工具类（静态方法，静态属性）
单例模式

package oupeng.week5.test;

public class Singleton {
    //饿汉式单例模式
    private static Singleton singleton=new Singleton();
    //1.私有化构造函数
    private Singleton(){
    }
    //2.给所有者提供一个创建好的对象
    public static Singleton getInstance(){
        return singleton;
    }
}

package oupeng.week5.test;

public class Singleton2 {
    //懒汉式单例模式
    private static Singleton2 singleton=null;
    //1.私有化构造函数
    private Singleton2(){
    }
    //2.给所有者提供一个创建好的对象
    public static Singleton2 getInstance(){
        if (singleton==null){
            singleton=new Singleton2();
        }
        return singleton;
    }
}

面向对象的专业术语
OO（Oriented Object）:面向对象
OOP（Oriented Object Programming）：面向对象的编程
OOD(Oriented Object Design)：面向对象的设计
OOA(Oriented Object Analysis)：面向对象的分析
OOT（Orient Object Test）：面向对象的测试

二、继承（inherit）

在面向对象中，类与类之间可以存在继承关系，Java是一种单继承编程语言。
Java实现继承的关键字：extends
父类（超类、基类）：
子类
private修饰的属性和方法不能被子类继承，protected修饰的方法，就是用来给子类继承的。
继承的功能：减少代码的重复，提高代码的复用度

class Person {
String name;
int age;
}
class Student extends Person{
public void study(){
System.out.println(name+"同学正在学习。。。。");
}
}
class Worker extends Person{
public void work(){

System.out.println(name+"工人正在工作。。。。");
}
}
public class TestPerson{
public static void main(String[] args) {
Student s = new Student();
s.name = "小明";
s.study();
Worker w = new Worker();
w.name = "张三";
w.work();
}
}

方法重写（覆盖）override

发生在继承中，指的是，子类继承父类的方法后，该方法不能满足子类，重写该方法。
子类访问修饰符权限>=父类
注解（annotation）:JDK5.0提供的新特性，利用反射技术，使用标注方法、属性
类等，从而扩展功能。@Override：表示该方法是重写的方法。@Deprecated：过时警告。@SuppressWarning：压制警告

class Fu{
void show(){
System.out.println("Fu show");
}
}
class Zi extends Fu{
void show(){
System.out.println("Zi show");
}
}

super

super在Java中，是一个指针，类似this关键字
this关键字指向创建的每一个对象
super自动指向父类
super()：调用父类的无参构造

对象的创建流程

1.使用javac命令将源码(.java)进行编译，生成字节码文件（.class）
2.javac命令执行字节码文件
3.将字节码文件加载进虚拟机中（JVM）,静态方法区开始加载静态资源
4.JVM从静态方法区读取主函数，并加载进栈（执行栈被创建出来）
5.主函数开始执行，执行创建对象
6.在堆内存中开辟对象的内存空间，并分配地址
7. 创建成员变量并进行默认初始化
8. 子类构造函数从非静态方法区加载进栈开始执行
9. 第一句先执行父类的构造函数
10. 父类构造函数执行，为子类继承到的成员变量进行初始化（对象内存空间里的父类空间）
11. 父类构造函数弹栈执行完成
12. 子类构造函数继续执行，此时先对成员变量进行显式初始化
13. 再执行子类构造函数的内容，进行针对性初始化
14. 执行完，子类构造函数弹栈，将对象的内存空间地址赋予相应的引用变量

方法区：（Method Area）
元数据区：（Metaspace）

instanceof关键字

作用：用来判断某个对象是否属于某个类。

字符串格式化方法

format

package oupeng.week5.test;

public class TestInstanceof {
    public static void main(String[] args) {
        double a=Math.PI;
        int age=18;
        String name="小明";
       System.out.println(String.format("name:%s,a:%s,PI:%.2f",name,age,a));
       System.out.printf("name:%s,a:%s,PI:%.2f",name,age,a);
    }

}

final

final修饰的变量称为常量。
一般书写为 ：static final int A=14;
final也可以修饰方法、类。final修饰的方法，子类无法重写；修饰类时，该类无法被继承。

内部类

定义在某个类内部的类
内部类可以直接访问外部类中的成员，但外部类不能直接访问内部类，若要访问，必须创建内部类
对象才能访问

非静态非私有内部类

当内部类在外部类成员位置上的时候，内部类就是外部类成员的一份子。这时这个内部类就可以使
用成员修饰符修饰，比如public、static、private
如果内部类的权限是非私有的，就可以在外部类以外的其他类中访问。即可以通过创建外部类对完
成访问内部类。

静态的非私有内部类

当内部类在外部类成员位置上被static修饰时，由于静态可以直接使用类名调用，则创建内部类对象
的方式：

package oupeng.week5.test;

public class TestInnerClass {
    public static void main(String[] args) {
      double s=  Math.PI;
        /*非静态内部类的访问
        Outer.Inner inner=new Outer().new Inner();
        inner.show();*/
        //静态内部类的访问
        new Outer.Inner().show();
        Outer.Inner i=new Outer.Inner();
        i.show();
        //内部类中静态方法的访问
        //Outer.Inner.show();
    }
}
class Outer{
    int num=5;
    static int num1=6;
   static class Inner{
       void show(){
           // System.out.println(num);
            System.out.println(num1);
        }
    }
}

静态导包

就是导入一个静态方法。

三、多态

在继承的基础上，才有多态，父类引用指向子类实例。
多态性是对象多种表现形式的体现。
多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

抽象方法

如果一个方法，不需要函数体，就可以声明抽象方法
抽象方法：没有函数体的方法。Java中使用abstract声明的方法就是抽象方法
访问修饰符 abstract 返回值类型 方法名称（参数列表）
抽象类：
被abstract关键字修饰的类。

public class Main {
    public static void main(String[] args) {
        Person p = new Student();
        p.run();
    }
}

abstract class Person {
    public abstract void run();
}

class Student extends Person {
    @Override
    public void run() {
        System.out.println("Student.run");
    }
}

注意：抽象类中不一定有抽象方法。如果一个类继承了抽象类必须实现该类的抽象方法，如果不实现，则将该类声明为抽象类。不能创建实例，有构造函数

接口

接口，本质是一种特殊的类，抽象类
接口中所有方法都是没有实现的（抽象方法）JDK8之前
接口中的所有属性和方法，默认都是public，即使不写。
Java中使用interface来定义
Java中，接口可以多实现。
接口的实现使用implements关键字实现接口，一旦实现了接口必须要实现接口中所有的抽象方法，如果不实现，则必须声明为抽象类。接口无法直接实例化，必须使用子类，以多态的形式完成实例化。
jdk8的接口新特性：
允许接口存在默认方法和静态方法，非抽象方法
默认方法：public default void 方法名(){
}//目的：等待子类实现。