面向对象：
    是一种思维方式，关注功能，关注具备功能的对象，关注结果，不关注实现过程。
    基于面向过程。
    将功能封装进对象，强调具备了功能的对象，不关注过程。就是将功能封装进类中，
    当我们想要使用到这个功能的时候，不需要考虑如何去完成这个功能，而是考虑谁具备了这个功能。
   
    类：现实事物的抽象，描述的是一类事物，现实事物特征、行为分别被抽象成了类中的成员变量与成员方法
    对象：某个类的实例，这个类的具体事物
   
    类与对象的关系：
        一个类可以有多个对象，创建对象是使用类的重要方式
        
[一] 封装：
    隐藏实现细节（把数据和方法包装进类中，隐藏属性和具体的实现），提供公共访问方式，被称作是封装。
   
    封装的结果是一个同时带有特征和行为的数据类型。
   
    定义类格式：
        public class 类名 {
            private 数据类型   变量名1;
            private 数据类型   变量名2;
            ...
            
            public xx method(XX xx) {
                //功能逻辑
            }

        }

[二] 继承：
    类与类之间的关系

    如果多个类具有相同的属性和行为，我们可以抽取出共性的内容定义父类，这时再创建相似的类时只要继承父类即可
   
    当一个类的属性与行为均与现有类相似，属于现有类的一种时，这一个类可以定义为现有类的子类
   
    子类会自动拥有父类所有可继承的属性和方法，无需重新定义。并且可以直接使用非私有的父类成员。
    从类与类之间的设计关系来看,子类必须属于父类的一种时，才会继承。
   
    继承的关键字 extends   
        子类   extends  父类{}
    继承的好处：
        提高了代表的可维护性
        提高了代码的复用性
        让类与类之间产生了继承关系
    继承的弊端：
        类与类之间的耦合度过高
    继承特点：
        java中类只能够单继承，不能多继承，可以多层继承
        class Ye extends Object {}
        class Fu extends Ye{}
        class Zi extends Fu {}
        所有的类都直接或者间接的继承了 Object类，Object类称为祖宗类
    继承的注意事项：
        1，使用关键字 extends 让类与类之间 产生继承关系
        2, 父类私有的成员，子类不能继承，因为根本看不到
        3，不能为了继承某个功能而随意进行继承操作，

[三] 多态
    (1)同一个对象，在不同时刻表现出来的不同状态。
        举例：水(水,冰,水蒸气)
              猫(猫,动物)
               
    (2)前提：
        A:有继承或者实现关系。
        B:有方法的重写。
        C:有父类(接口)的引用指向子类对象。
    (3)多态中的成员使用特点：
        Fu fz = new Zi();
        多态时，所有表现形式都是父类的表现形式，
        只有调用方法时，运行的是子类重写的方法
        A:成员变量
            编译看左边，运行看左边。
        B:成员方法
            编译看左边，运行看右边。

         class Fu {
            int num=1;
            void show() {
                System.out.println("showFu");
            }
        }
        class Zi extends Fu {
            int num=2;
            void show() {
                System.out.println("showZi");
            }
        }
        class T {
            public static void main(String[] args) {
                Fu f=new Zi();
                System.out.println(f.num);  
                f.show();   
               
            }

    (4)多态中的转型：
        A:向上转型
            把子类对象赋值给父类(接口)的引用  自动类型提升  int a = 0;  double b =a;
        B:向下转型
            把父类(接口)的引用强制转换成子类对象
            double b = 10.0;
            int a = (int)b;

            Fu  fz = new Zi();(前提)
            Zi  zf = (Zi)fz;


    (5)多态的好处及弊端：
        A:好处
            提高了程序可维护性和可扩展性。
            
        B:弊端
            不能使用子类特有内容。
            要想使用，要么向下转型，要么重新创建子类对象。
    (6)多态的三种形式：
        A:具体的类多态   父类  变量名 = new  子类();
            public class Fu {
                public void show(){
                    System.out.println("父类的show方法");
                }
            }
            public class Zi extends Fu{
                @Override
                public void show(){
                    System.out.println("子类重写父类的show方法");
                }
            }
            Fu fu= new Zi();
        B:抽象类多态     父抽象类  变量名 = new 子类();
            public abstract class Fu {
                public abstract void method();
            }
            public class Zi extends Fu {
                public void method(){
                    System.out.println(“重写父类抽象方法”);
                }
            }
            //类的多态使用
            Fu fu= new Zi();
        C:接口多态       接口  变量名  =  new 实现类();
        public interface Fu {
            public abstract void method();
        }
        public class Zi implements Fu {
            public void method(){
                System.out.println(“重写接口抽象方法”);
            }
        }

面向对象：
    是一种思维方式，关注功能，关注具备功能的对象，关注结果，不关注实现过程。
    基于面向过程。
    将功能封装进对象，强调具备了功能的对象，不关注过程。就是将功能封装进类中，
    当我们想要使用到这个功能的时候，不需要考虑如何去完成这个功能，而是考虑谁具备了这个功能。
   
    类：现实事物的抽象，描述的是一类事物，现实事物特征、行为分别被抽象成了类中的成员变量与成员方法
    对象：某个类的实例，这个类的具体事物
   
    类与对象的关系：
        一个类可以有多个对象，创建对象是使用类的重要方式
        
[一] 封装：
    隐藏实现细节（把数据和方法包装进类中，隐藏属性和具体的实现），提供公共访问方式，被称作是封装。
   
    封装的结果是一个同时带有特征和行为的数据类型。
   
    定义类格式：
        public class 类名 {
            private 数据类型   变量名1;
            private 数据类型   变量名2;
            ...
            
            public xx method(XX xx) {
                //功能逻辑
            }

        }

[二] 继承：
    类与类之间的关系

    如果多个类具有相同的属性和行为，我们可以抽取出共性的内容定义父类，这时再创建相似的类时只要继承父类即可
   
    当一个类的属性与行为均与现有类相似，属于现有类的一种时，这一个类可以定义为现有类的子类
   
    子类会自动拥有父类所有可继承的属性和方法，无需重新定义。并且可以直接使用非私有的父类成员。
    从类与类之间的设计关系来看,子类必须属于父类的一种时，才会继承。
   
    继承的关键字 extends   
        子类   extends  父类{}
    继承的好处：
        提高了代表的可维护性
        提高了代码的复用性
        让类与类之间产生了继承关系
    继承的弊端：
        类与类之间的耦合度过高
    继承特点：
        java中类只能够单继承，不能多继承，可以多层继承
        class Ye extends Object {}
        class Fu extends Ye{}
        class Zi extends Fu {}
        所有的类都直接或者间接的继承了 Object类，Object类称为祖宗类
    继承的注意事项：
        1，使用关键字 extends 让类与类之间 产生继承关系
        2, 父类私有的成员，子类不能继承，因为根本看不到
        3，不能为了继承某个功能而随意进行继承操作，

[三] 多态
    (1)同一个对象，在不同时刻表现出来的不同状态。
        举例：水(水,冰,水蒸气)
              猫(猫,动物)
               
    (2)前提：
        A:有继承或者实现关系。
        B:有方法的重写。
        C:有父类(接口)的引用指向子类对象。
    (3)多态中的成员使用特点：
        Fu fz = new Zi();
        多态时，所有表现形式都是父类的表现形式，
        只有调用方法时，运行的是子类重写的方法
        A:成员变量
            编译看左边，运行看左边。
        B:成员方法
            编译看左边，运行看右边。

         class Fu {
            int num=1;
            void show() {
                System.out.println("showFu");
            }
        }
        class Zi extends Fu {
            int num=2;
            void show() {
                System.out.println("showZi");
            }
        }
        class T {
            public static void main(String[] args) {
                Fu f=new Zi();
                System.out.println(f.num);  
                f.show();   
               
            }

    (4)多态中的转型：
        A:向上转型
            把子类对象赋值给父类(接口)的引用  自动类型提升  int a = 0;  double b =a;
        B:向下转型
            把父类(接口)的引用强制转换成子类对象
            double b = 10.0;
            int a = (int)b;

            Fu  fz = new Zi();(前提)
            Zi  zf = (Zi)fz;


    (5)多态的好处及弊端：
        A:好处
            提高了程序可维护性和可扩展性。
            
        B:弊端
            不能使用子类特有内容。
            要想使用，要么向下转型，要么重新创建子类对象。
    (6)多态的三种形式：
        A:具体的类多态   父类  变量名 = new  子类();
            public class Fu {
                public void show(){
                    System.out.println("父类的show方法");
                }
            }
            public class Zi extends Fu{
                @Override
                public void show(){
                    System.out.println("子类重写父类的show方法");
                }
            }
            Fu fu= new Zi();
        B:抽象类多态     父抽象类  变量名 = new 子类();
            public abstract class Fu {
                public abstract void method();
            }
            public class Zi extends Fu {
                public void method(){
                    System.out.println(“重写父类抽象方法”);
                }
            }
            //类的多态使用
            Fu fu= new Zi();
        C:接口多态       接口  变量名  =  new 实现类();
        public interface Fu {
            public abstract void method();
        }
        public class Zi implements Fu {
            public void method(){
                System.out.println(“重写接口抽象方法”);
            }
        }