面向对象
        面向对象是软件开发过程中的一种思维方式。将功能封装到类中，当我们想使用这个功能时候，不去考虑如何实现，
        考虑哪个类具备这个功能。 将功能封装进对象，强调了具备功能的对象，不关注过程。
        面向对象是基于面向过程的，因为一个功能如果你不去完成，必定要有其他人完成。

        举个栗子：
               
        好处
                更符合人们思考习惯的思想
                将复杂的问题简单化
                将程序由执行者变成了指挥者
        三大特征
                封装
                继承
                多态
类的基本概念
        具有相同特征(属性)和行为(功能)的一类事物的抽象。
        成员变量对应事物的属性
        成员方法对应事物的行为
        无论成员变量还是成员方法都属于类的成员
       
        成员变量和局部的区别
                成员变量
                        定义位置:类中方法外，整个类中生效。
                        内存位置:随着对象存储在堆内存中
                        默认值:有默认值
                        回收:随着对象的回收而回收
                局部变量
                        定义位置:方法或者语句内，在当前方法或者语句中生效。
                        内存位置:栈内存中
                        默认值:没有默认值
                        回收:随着作用域的结束而回收。
       
        成员方法
                功能性方法
                get/set方法

类与对象关系
        类代表一类事物，是抽象的概念，根据这一类事物创建出的具体实例。
        一个类可以有多个对象，创建对象是一个类最重要的使用方式
this
        当前对象的引用
        this可以访问当前对象的成员变量    this.变量名
        this可以访问成员方法                  this.方法名()
        this可以访问本类的其他构造方法    this(参数)

super
        当前对象中的父类对象的引用
        super可以方法父类对象的成员变量   super.变量名
        super可以访问父类成员方法         super.方法名()
        super可以访问父类的构造方法          super(参数)

构造方法
        创建对象时调用的方法。无参构造和带参构造
        如果没有手动给出构造方法，系统会为我们自动补齐一个无参的构造方法。
        如果手动给出任意一个构造方法，系统都不会再补齐无参构造了。
        当子类创建对象时，会在每个构造方法的第一行默认调用父类的无参构造super();
       
        修饰符  类名(){
       
        }


private
        私有化修饰符，权限修饰符的一种。private可以修饰成员，用private修饰的成员外界无法直接方法。

        public class Person{
                private String name;
                private int age;
               
                无参构造
                public Person(){}
       
                带参构造
                public Person(String name,int age){
                        this.name = name;
                        this.age = age;
                }

                public void eat(){
                        System.out.println("吃了");
                }

                get/set
               
        }


继承
        概念一
                当要定义一个类时，发现已有类与要定义的类相似，并且要定义的这个类属于已有类的一种时，就可以将要定义的这个类定义为已有类的子类。
        概念二
                当多个类都有相同的属性和行为时，可以将共性的内容抽取到一个新的类中，让新的类与原有的多个类形成一个关系，这个关系就是继承。

        继承后，子类可以使用父类的非私有的属性和行为。

        继承的好处
                提高代码的复用性
                让类与类之间产生了关系，是多态的前提。
        方法重写       
                子类继承父类时，可以继承父类的所有非私有的方法和属性。当发现继承过来的方法不够强大，不能满足子类需求时，
                可以将继承过来的方法重新定义，这个过程就是方法重写，方法复写，方法覆盖。
       
        方法重写与方法重载的区别
                方法重写必须有继承关系，是子类重写父类的方法。
                方法重载在一个类中，方法名相同，参数列表不同。
       

        public class Student extends Person{
                private String number;

                无参构造
                public Student(){}

                带参构造
                public Student(String name,int age,String number){
                        super(name,age);
                        this.number = number;
                }

                public void eat(){
                        System.out.println("吃学生套餐");
                }

                public void study(){
                        System.out.println("学习");
                }

                get/set
       
        }

多态
        一个事物不同时刻的不同形态。

        父类(或者接口)引用指向子类(实现类)对象，调用方法时，调用的是父类的方法，但是在运行时，运行的是子类重写后的方法。
       
        成员变量
                编译时 看左边   运行时 看左边
        成员方法
                编译时 看左边   运行时 看有边


        Person p = new Studnet();

        p.eat();

        //向下转型

        Student s=(Student)p;
        s.study();

        向上转型
                多态本身就是向上转型
        向下转型
                通过强制类型转换，将向上转型的子类对象，转换回子类对象。

        多态的好处
                提高了可维护性和可扩展性
                对修改关闭，对扩展开放
       
        多态的形式
                具体类的多态  
                抽象类的多态
                接口的多态











抽象类与接口的区别
        成员的区别

                成员变量   
                        抽象类可以是变量，也可以是常量
                        接口里边定义的都是常量 public static final
                成员方法
                        抽象类可以有具体的方法，也可以有抽象方法
                        接口里面的方法都是抽象方法   public abstract
                构造方法
                        抽象类有构造方法 用于子类创建实例
                        接口没有构造方法
        类与接口关系的区别
               
                类与类是继承关系，只能单继承，不能多继承，可以多层继承

                类与接口是实现，可以多事项，一个类可以在继承一个父类后实现多个接口。

                接口与接口是继承关系，可以多继承。
       
        理念上不同
                抽象类是用来描述一类事物基本属性和行为

                接口是功能的集合。



       

        public interface Fly{
               
                public abstract void method1();
                public abstract void method2();
                public abstract void method3();
        }

        public abstract class Person implements Fly{
               
               
                public abstract void eat();
               
                public abstract void method1();
                public abstract void method2();
                public abstract void method3();
       
       
        }

       

       
               

面向对象
        面向对象是软件开发过程中的一种思维方式。将功能封装到类中，当我们想使用这个功能时候，不去考虑如何实现，
        考虑哪个类具备这个功能。 将功能封装进对象，强调了具备功能的对象，不关注过程。
        面向对象是基于面向过程的，因为一个功能如果你不去完成，必定要有其他人完成。

        举个栗子：
               
        好处
                更符合人们思考习惯的思想
                将复杂的问题简单化
                将程序由执行者变成了指挥者
        三大特征
                封装
                继承
                多态
类的基本概念
        具有相同特征(属性)和行为(功能)的一类事物的抽象。
        成员变量对应事物的属性
        成员方法对应事物的行为
        无论成员变量还是成员方法都属于类的成员
       
        成员变量和局部的区别
                成员变量
                        定义位置:类中方法外，整个类中生效。
                        内存位置:随着对象存储在堆内存中
                        默认值:有默认值
                        回收:随着对象的回收而回收
                局部变量
                        定义位置:方法或者语句内，在当前方法或者语句中生效。
                        内存位置:栈内存中
                        默认值:没有默认值
                        回收:随着作用域的结束而回收。
       
        成员方法
                功能性方法
                get/set方法

类与对象关系
        类代表一类事物，是抽象的概念，根据这一类事物创建出的具体实例。
        一个类可以有多个对象，创建对象是一个类最重要的使用方式
this
        当前对象的引用
        this可以访问当前对象的成员变量    this.变量名
        this可以访问成员方法                  this.方法名()
        this可以访问本类的其他构造方法    this(参数)

super
        当前对象中的父类对象的引用
        super可以方法父类对象的成员变量   super.变量名
        super可以访问父类成员方法         super.方法名()
        super可以访问父类的构造方法          super(参数)

构造方法
        创建对象时调用的方法。无参构造和带参构造
        如果没有手动给出构造方法，系统会为我们自动补齐一个无参的构造方法。
        如果手动给出任意一个构造方法，系统都不会再补齐无参构造了。
        当子类创建对象时，会在每个构造方法的第一行默认调用父类的无参构造super();
       
        修饰符  类名(){
       
        }


private
        私有化修饰符，权限修饰符的一种。private可以修饰成员，用private修饰的成员外界无法直接方法。

        public class Person{
                private String name;
                private int age;
               
                无参构造
                public Person(){}
       
                带参构造
                public Person(String name,int age){
                        this.name = name;
                        this.age = age;
                }

                public void eat(){
                        System.out.println("吃了");
                }

                get/set
               
        }


继承
        概念一
                当要定义一个类时，发现已有类与要定义的类相似，并且要定义的这个类属于已有类的一种时，就可以将要定义的这个类定义为已有类的子类。
        概念二
                当多个类都有相同的属性和行为时，可以将共性的内容抽取到一个新的类中，让新的类与原有的多个类形成一个关系，这个关系就是继承。

        继承后，子类可以使用父类的非私有的属性和行为。

        继承的好处
                提高代码的复用性
                让类与类之间产生了关系，是多态的前提。
        方法重写       
                子类继承父类时，可以继承父类的所有非私有的方法和属性。当发现继承过来的方法不够强大，不能满足子类需求时，
                可以将继承过来的方法重新定义，这个过程就是方法重写，方法复写，方法覆盖。
       
        方法重写与方法重载的区别
                方法重写必须有继承关系，是子类重写父类的方法。
                方法重载在一个类中，方法名相同，参数列表不同。
       

        public class Student extends Person{
                private String number;

                无参构造
                public Student(){}

                带参构造
                public Student(String name,int age,String number){
                        super(name,age);
                        this.number = number;
                }

                public void eat(){
                        System.out.println("吃学生套餐");
                }

                public void study(){
                        System.out.println("学习");
                }

                get/set
       
        }

多态
        一个事物不同时刻的不同形态。

        父类(或者接口)引用指向子类(实现类)对象，调用方法时，调用的是父类的方法，但是在运行时，运行的是子类重写后的方法。
       
        成员变量
                编译时 看左边   运行时 看左边
        成员方法
                编译时 看左边   运行时 看有边


        Person p = new Studnet();

        p.eat();

        //向下转型

        Student s=(Student)p;
        s.study();

        向上转型
                多态本身就是向上转型
        向下转型
                通过强制类型转换，将向上转型的子类对象，转换回子类对象。

        多态的好处
                提高了可维护性和可扩展性
                对修改关闭，对扩展开放
       
        多态的形式
                具体类的多态  
                抽象类的多态
                接口的多态











抽象类与接口的区别
        成员的区别

                成员变量   
                        抽象类可以是变量，也可以是常量
                        接口里边定义的都是常量 public static final
                成员方法
                        抽象类可以有具体的方法，也可以有抽象方法
                        接口里面的方法都是抽象方法   public abstract
                构造方法
                        抽象类有构造方法 用于子类创建实例
                        接口没有构造方法
        类与接口关系的区别
               
                类与类是继承关系，只能单继承，不能多继承，可以多层继承

                类与接口是实现，可以多事项，一个类可以在继承一个父类后实现多个接口。

                接口与接口是继承关系，可以多继承。
       
        理念上不同
                抽象类是用来描述一类事物基本属性和行为

                接口是功能的集合。



       

        public interface Fly{
               
                public abstract void method1();
                public abstract void method2();
                public abstract void method3();
        }

        public abstract class Person implements Fly{
               
               
                public abstract void eat();
               
                public abstract void method1();
                public abstract void method2();
                public abstract void method3();
       
       
        }