面向对象概述   
   对于面向对象思想,强调的是对象(实体),C++,java,C#都属于面向对象语言.
    特点:  1.面向对象就是一种常见的思想.符合人们的思考习惯.
            2.面向对象的出现,将复杂的问题简单化;
            3.面向对象的出现,让曾经在过程中的执行者,变成了对象中的指挥者.
   
   面向对象的三大特征: 封装 ,继承,多态;
   
  类与对象之间的关系
    用java语言对现实生活中的事物进行描述.通过类的形式来体现的..对于类的事物描述只关注两个方面:第一个是属性,第二个是行为;只要明确该事物的属性和行为并定义在类中即可.
    
    类:事物的描述.定义类其实就是在定义类中的成员;
        类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。
        成员:成员变量---属性,成员函数-----行为.
    
    成员变量和局部变量的区别:
     1.成员变量定义在类中,整个类中都可以访问;
       局部变量定义在函数,语句,局部代码块中,只有在所属的区域有效;
    
     2.成员变量存在于堆内存的对象中;
       局部变量存在于栈内存的方法中;
    
     3.成员变量随着对象的创建而存在,随着对象的消失而消失;
       局部变量随着所处区域的执行而存在,随着所属区域的结束而释放;
    
     4.成员变量都有默认的初始化值;
       局部变量没有默认的初始化值,所有局部变量需要先初始化才能用.
      
    对象: 该类事物的实例,其实就是该类事物实实在在存在的个体. 对象简单来说是封装一个事物中具备的数据.
    匿名对象:可以说是没有名字的对象
              例如:new Car();//匿名对象,就是定义对象的简写格式 
                   new Car().run();
              1.当对象对方法进行一次调用的时候,就可以简写成匿名对象.
              2.匿名对象可以作为实际参数进行传递,如:show(new Car()); 
  

//描述一个下汽车class Car{int num;//轮胎数String color;//颜色void run(){System.out.println(num+""+color);}}class  CarDemo{public static void main(String[] agrs){//在计算机中创建一个car实例,通过new关键字Car c = new Car();//c就是一个类型的引用变量,指向了该类的对象c.num = 4;         //通过对象调用自己的成员变量(属性)并赋值c.color = "red";c.run();//要使用对象中的内容可以通过 对象..成员的形式来完成}}

  一.封装(Encpsulation)
    是指隐藏对象的属性和实现细节,反对对外提供公共访问方式.
    好处:1.将变化隔离;2.便于使用;3.提高重用性;4.提高安全性.
    封装的原则:将不需要对外提供的内容都隐藏起来,把属性都隐藏,提供公共方法对其访问;
    

<strong>class Person{private int age;//private:私有化,是一个权限修饰符,用于修饰成员.私有的内容只有在本类中有效//注意:私有仅仅只是封装的一种体现而已 Person(){} //构造函数Person(){int age} //构造函数重载public void setAge(int age){this.age=age;  //this.它是所在函数所属对象的引用.}public int getAge(){return age;}}</strong>

    构造函数:构造对象时调用的函数.
        特点:1.函数名与类名相同; 2.不用定义返回值类型;3.没有具体的返回值(可以写,但很少) 4.多个构造函数是以重载的形式存在的(注:重载指构造函数(函数)的方法名相同,方法中的参数类型或参数个数不同)
        作用:给对象进行初始化. 创建对象都必须要通过构造函数的初始化.
        一个类中如果没有定义过构造函数,那么该类中会有一个默认的空参数构造函数,如果在类中定义了指定的构造函数,那么类中默认的构造函数就不存在了.
     构造函数和一般函数区别:
     构造函数:对象创建时,就回调用与之对应的构造函数,给对象进行初始化;并且只调用一次
     一般函数:对象创建后,需要函数功能时而调用.

     
     this关键字
      当成员变量和局部变量重名,用关键字this,它代表对象,代表当前对象;
      this就是所在函数所属对象的引用,简单的说哪个对象调用了this所在函数,this就代表哪个对象.
      一个类中他的所有成员只要想执行,必须有对象调用(除静态static以外)

 Person(String name){this,name = name;}Person(String name,int age){this(name);   //this也可以用于构造函数中调用其他构造函数.this,age = age;}

注意:只能定义在构造函数的第一行,因为初始化动作要先执行.
     
      static关键字(静态)
       可共享数据 如: static String County = "CN";
      特点:1.static是一个修饰符,用于修饰成员,方法;
             2.static 修饰的成员被所属对象所共享;
             3.static优先于对象的存在,因为static成员随着类的加载就已经存在;
             4.static修饰的成员多了一种调用方式,直接被类名所调用.(类名.静态成员)
             5.static修饰数据是共享数据,对象中的存储的是特有数据没有被共享.
       成员变量和静态变量
       String name;//成员变量(实例变量)  static  String name;//静态变量
       区别: 1.成员变量随着对象的创建而存在,随着对象的被回收而消失;
               静态变量随着类的加载而存在,随着类的消失而消失;
             2.调用方式不同:成员变量只能被对象调用; 静态变量可以被对象调用,还可以被类名调用 ;
             3.别名不同:成员变量也叫实例变量. 静态变量也称类变量;
             4.数据存储的位置不同:成员变量数据存在堆内存对象中,也称特有数据. 静态变量数据存在于方法区(共享数据区)的静态区.所以也称对象的共享数据. 
      静态使用注意事项:(静态比类先加载)
       1.静态方法只能访问静态成员.(非静态可访问静态,也可访问非静态)
       2.静态方法中不可以使用this或super关键字;
       3.主函数main就是静态的.(特殊之处:1.格式是固定的;2.被JVM识别和调用) 
       静态什么时候用:
     1.静态变量
       当分析对象中所具备的成员变量的值都相同的时候,这个成员可以被静态修饰.

        只要数据在对象中都是相同的,对象不需要修改,只需要使用即可,不用存储在对象中,是静态.
        只要数据在对象中都是不同的,就是对象的特有数据,必须存储在对象中,是非静态的.
      2.静态函数
        函数是否用静态修饰,就参考一点,该函数功能是否有访问到对象中的特有数据.简单的说,从源代码看,该功能是否需要访问静态的成员变量,如果需要,该功能就是静态的,如果不需要,就可以将该功能定义成非静态
          

      static{//静态函数代码块:随着类的加载而执行,只执行一次; (最先执行)}{//构造代码块:给所有对象初始化(跟类没关系)(如果有对象,构造代码块再执行) } Person(){// 构造函数:针对Person()对象初始化(最先执行) (然后执行构造函数)}public void show(){{// 局部代码块:给局部定义的生命周期(最先执行) (在方法中顺序执行)}}

二.继承(extends)

       优点:(1).提高代码复用性,能够大大缩短开发周期，降低开发费用;(2).让类与类之间产生了关系,给第三特征多态提供前提;

       java中支持多层(多重)继承,C继承B,B继承A,就会出现集成体系.
       java中支持单继承,不支持多继承,因为如果有多个父类有相同成员,会出现不确定性,但对C++中的多继承机制进行了改良.java中的多继承是通过多实现的方式来体现的.

       当类与类之间存在这所属关系的时候,就定义继承.例如 a 是 b 中的一种,a  extends  b;当子类和父类的成员变量同名用super区分父类.当本类成员变量和局部变量同名用this区分变量,所以this和super用法很相似.
       super:并不代表一个父类对象,它代表一个父类的空间.当子类中出现成员函数一模一样的情况,会运行子类的函数.
       当子类对象调用成员函数,而这个成员函数在子类和父类中一样的情况下,会运行子类的函数,这种现象称为覆盖操作,这是函数在子父类中的特性.(但没有真正的覆盖,父类的方法还是在,只是子类对象优先考虑自己本类的成员函数)
      

 class Fu{void show(){System.out.println("fu show run");}}class  Zi extends Fu{void show(){System.out.println("Zi show run");}} class Test{public static void  main(String[]agrs){Zi z = new Zi();z.show();//结果是Zi show run }}

子父类构造函数
    当子类构造对象访问子类构造函数时,父类的构造函数也运行了.原因是:构造函数没有覆盖,也没有继承,在子类构造函数的第一行有默认隐式的语句super(); 所以所有构造函数默认会访问父类中空参数的构造函数,称为子类的实例化过程.
        为什么子类实例化要访问父类呢? 原因是:因为子类继承父类,获取了父类中的属性,所以在使用父类的属性之前,先看父类如何对自己属性初始化,这个是必须的动作,所以加入了隐式默认的super();语句.如果父类没有定义空参数构造函数,此时super要明确调用父类那个构造函数,super在子类必须第一行,因为父类初始化必须先完成.
        如果子类构造函数使用了this();调用了本类构造函数时,该构造函数(有this();的构造函数)的super就消失了! 但是可以保证子类会有其他构造函数去访问父类的构造函数.
       接口---多实现 
       一个类可以实现多个接口(以逗号","隔开);一个类在继承另一个类的同时,还可以实现多个接口.
       优点:接口的出现避免了单继承的局限性.接口与接口之间是继承关系.
       接口的特点: (1)接口是对外暴露的规则;
                            (2)接口是程序的扩展功能;
                            (3)接口的出现降低耦合性(简称:解耦);
                            (4)接口可以用来多实现;
                            (5)类与接口之间是实现关系,而且类可继承一个类的同时实现多个接口;
                            (6)接口与接口之间可以有继承关系.
                            (7)接口的方法都是抽象方法和抽象成员,并且有固定的修饰符(interface). 
       
 三.多态
   某一类事物的多种存在形态.函数具有多态性,对象本身也具有多态性.简单地说:就是一个对象对应着不同类型(一个对象两种形态).例如:猫这个对象对应着猫,但同时它也对应着动物.多态的体现:父类或接口的引用指向子类的对象.
     多态的好处:优点:提高代码扩展性,前期定义的代码可以使用后期的内容.
                            缺点:前期的内容不能调用后期子类特有的方法.(自动类型的提升限制了对特有功能的访问)
    多态的前提:(1)必须有继承或实现的关系;(2)必须有覆盖(子类的方法,父类中也必须有).
    多态的特点:(1)成员函数:编译时:参考引用变量所属类中是否有调用函数,运行时:参考对象所属类中是否有调用函数.(编译看左边,运行看右边)(2)成员变量:编译时:参考引用变量所属类中是否有调用的成员变量,运行时:参考引用变量所属类中是否有调用成员变量,并运行所属类中的成员变量.(编译看左边,运行看左边)(3)静态函数:同上.编译看左边,运行看左边;

 

class Fu{int num = 3;void show(){System.out.println("fu show run");}static void show1{System.out.println("fu static show run"); }}class  Zi extends Fu{int num = 4; void show(){System.out.println("Zi show run");}static void show1(){System.out.println("Zi static show run"); } } class Test{public static void  main(String[]agrs){Fu z = new Zi();z.num;//其中值为3,因为当对象一创建,在堆中出现类两个num,子类型提升为了父类类型,所以会找父类中的成员变量num                // 如果父类型中没有num,编译会失败.z.show();//结果是Zi show run 因为父类引用的对象z对应的子类对象,z存的内存地址是new Zi();会找子类的方法//如果子类型没有show()方法,回去找父类中的show()方法z.show1();//结果是fu static show run 因为show1是静态方法,不依赖对象,依赖的是类,Fu类类型引用,就会找Fu所属类的方法,如果父类型中没有show1(),编译会失败. }}