面向对象

面向对象：

面向对象是基于面向过程的，是一种编程思想。

所谓，万物皆对象，每个对象都有自己的属相和方法。面向对象是将功能封装进对象

面向过程：强调的是功能行为

面向对象：将功能封装进对象，强调具备功能的对象

面向对象将：执行者转换成指挥者

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

面向对象举例：    买电脑（执行者转换成指挥者）

        假如一个人去买电脑，他对电脑一窍不通，那么他可以找一位懂电脑的朋友，带着朋友去电子城购买电脑

他不需要懂电脑的任何东西，只要告诉朋友，我需要什么价位的电脑，做什么用，那么朋友就可以帮助他购买，

在这其中，他扮演的就是指挥者，他的朋友就是执行者，从他要买电脑（执行者）转换为他邀请他朋友帮助他购买（指挥者）

类和对象的关系：

                类：对现实生活中事物的描述

                对象：就是这类事物实实在在存在的个体

                        属性：对应类中的    成员变量

                        行为：对应类中的    成员函数

    

        例如：

                类：描述一个汽车的属性：颜色、轮胎数，方法：跑

                 对象：创建一个汽车对象，实实在在存在的个体

    

局部变量：定义在方法、语句、或代码块中，没有初始化值（需要初始化），作用域整个大括号，在栈内存中存储，声明周期较短

成员变量：定义在类中，方法体外，有初始化值（有默认值，创建对象时初始化值），作用域整个类，在堆内存中存储，声明周期较长

static：修饰符，用于修饰成员（成员变量和成员函数）。

         当被静态修饰后，就多了一种调用方式，即：类名.静态

         静态的使用：工具类（Tool），定义一个类，类中是静态的公共方法（在不需要操作类中特有属性的前提下，可以通过类名直接调用，因为不创建对象，无法访问类中特有的属性）

特点：

1、随着类的加载而加载，随着类的消失而消失，也就是生命周期最长。

2、优先于对象存在。静态先存在，对象后存在

3、被所有对象所共享

4、可以直接被类名调用

5、静态方法只能访问静态成员（方法和变量）【非静态方法可以访问静态方法】

6、静态方法中不可以定义this，super关键字

                   因为静态优先于对象存在，this存在于对象中，没对象，不可以访问

成员变量（实例变量）：随着对象的建立而建立，存在与堆内存中，

静态成员变量（类变量）：随着类的加载而加载，存在于方法区中，生命周期最长

匿名对象：即：没有名字的对象

        new Car（）.run（）：

                        匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成

                                              如果对一个对象进行多个成员调用使用，必须给这个对象起个名字

                        匿名对象使用方式二：可以直接将匿名对象作为实际参数进行传递

匿名对象类的代码使用案例

/*匿名对象：是没有名字的对象。应用场景：A:当对对象方法仅进行一次调用的时B:匿名对象可以作为实际参数进行传递*/class Student{  public void show()  {   System.out.println("student -- show");  }}class Test{  //引用类型作为形式参数  public void print(Student s)  {    s.show();  }  public void print(int a)  {    System.out.println(a);  }}class NiMingTest {    public static void main(String[] args)    {    //如何使用show()方法呢?    Student s = new Student();    s.show();    //匿名对象的使用    new Student().show();    Test t = new Test();   //Student s2 = new Student();   //t.print(s2);   t.print(new Student());  }}

代码块执行顺序：

1，静态代码块：用于给类进行初始化。随着类的加载而执行，且只执行一次，优先于主函数执行（只要用到类（构造函数），类就会加载，静态代码块就会执行）

2，构造代码块：用于给所有对象初始化，对象一建立就运行，并优先于构造函数运行

（构造代码块中是所有对象共性的内容）

3，构造函数：与类名同名，用于给对象初始化（当类中定义了构造函数后，默认的构造函数就没有了。不用定义返回值类型，不用写return语句）

面向对象有三大特征：封装、继承和多态          

封装是继承的前提，继承是多态的前提

一、封装：隐藏对象的属性和实现细节，仅对外提供公共的访问方式

            封装原则：将不需要对外提供的内容隐藏起来，提供公共方法对其访问

            例如：由于不懂电脑，找人去买电脑，我不需要知道他是怎么跟卖电脑的进行砍价，进行交谈的

                       我只要知道他把电脑给我买上就行

           封装的好处：便于使用，提高重用性和安全性

                private ：权限修饰符，用于修饰类中的成员（成员变量、成员函数）

                class Person

                {

                        一个变量通常有两种访问方式：1、获取（get）    2、设置（set）

                        private int age：将age私有化以后，除了Person类外，其他类无法访问

                         public void setAge(int age)    为了能是其他类可以访问age，定义一个函数，用来改变age的值

                          {

                                this.age=age;

                            }

                }

            注意：私有（private）仅仅是封装的一种表现形式

this关键字使用：         

this：用于区分成员变量和局部变量。this：那个对象在调用this所在的函数，this就代表那个对象this语句：用在构造函数之间进行互相调用，且this语句必须放在第一行，因为要给对象进行初始化

二、继承：让类与类之间产生关系，提高了代码的复用性，是多态的一种前提

1、Java只支持单继承，不支持多继承，但java保留了这种机制，并用另一种体现形式来完成表示：多实现

因为多继承容易带来安全隐患，当多个父类中定义了相同功能，但功能内容不同时，子类对象不确定要执行那个一个

class SubDemo extends Demo{} //okclass SubDemo extends Demo1,Demo2...//error

2、Java支持多层继承：A继承B，C继承A

class A{}class B extends A{}class C extends B{}

           子父类中变量的特点：

                    子类中出现非私有的同名变量时，子类要访问本类变量：this.变量名

                                                                        子类要访问父类变量：super.变量名

代码体现：

class Fu //定义父类{int num = 4;public void setNum(int num){this.num =num;}public int getNum(){return this.num;}}//子类继承父类class Zi extends Fu<span style="white-space:pre"></span>{int num = super.num;//访问父类中的成员变量void show(){System.out.println("num="num);}}class  ExtendsDemo{public static void main(String[] args) {Zi z = new Zi();//创建子类对象z.show();}}

执行结果

           子父类中函数的特点：

                    子类中出现和父类一模一样的函数时，父类中的函数会被子类的函数所覆盖

                                                                               子类覆盖父类，必须保证子类权限大于父类权限

                   函数的重载：函数名相同，参数列表不同

                   函数的重写：函数名和参数列表都相同

代码体现：

class Fu //创建父类{void show()//父类中的show方法{System.out.println("fu show");}}//子类继承父类class Zi extends Fu{//子类复写父类中的show方法void show(){System.out.println("zi show");}}class  ExtendsDemo{public static void main(String[] args) {Zi z = new Zi();z.show();}}

执行结果：

            

           子父类中构造函数的特点：

                  子类的构造函数第一行有一条隐士的语句：super（）用来调用父类中的空参的构造函数

                            因为父类中的数据，子类可以直接获取，所以，子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的，所以子类创建对象时要先访问父类中的构造函数  

                            如果要访问父类中指定的构造函数，可以通过super语句来指定

                            如果要访问父类中没有空参的构造函数，必须指定super要访问父类中哪一个

                        子类至少要访问一个父类中的构造函数

代码体现：

class Fu //创建父类{int num;//父类中的成员变量Fu()//父类构造方法{num = 60;//在对象初始化时，给变量赋值System.out.println("fu run,,"+num);}Fu(int x) //父类带参的构造方法{this();//this语句，访问父类中空参的构造方法System.out.println("fu.."+x);}}class Zi extends Fu<span style="white-space:pre"></span>//子类继承父类{Zi()<span style="white-space:pre"></span>//子类空参的构造函数{super(4);//方法父类中带参的构造方法System.out.println("zi run");}Zi(int x)<span style="white-space:pre"></span>//子类带参的构造函数{this();//访问子类中空参的构造函数System.out.println("zi....."+x);}}class  ExtendsDemo{public static void main(String[] args) {Zi z = new Zi(10);//创建子类对象，并传递参数System.out.println(z.num);}}

执行结果：

子父类中代码块的执行顺序：

           父类的静态代码块 --- 子类的静态代码块 --- 父类的构造代码块 --- 父类的构造函数 --- 子类的构造代码块 --- 子类的构造函数

           final关键字：这是一个修饰符，可以修饰类、方法、变量 

                        1、被final修饰的类是一个最终类，不可以被继承

                        2、被final修饰的方法是一个最终方法，不可以被覆盖

                        3、被final修饰的变量是一个常量，只能赋值一次

                final既可以修饰成员变量，又可以修饰局部变量

                        内部类定义在类中的局部变量位置上时，只能访问被final是修饰的局部变量

三、多态：事物存在的多种体现形态

多态的表现：父类引用指向子类对象

  父类的引用也可以接收自己的子类对象

多态的前提：必须是类与类之间有关系，要么继承，要么实现

                                 通常还有一个前提，存在：覆盖

多态的好处：提高了程序的扩展性

多态的弊端：提高了扩展性，但是只能使用父类的引用访问父类中的成员

            

            转型：

            

                注意：

 我们能转换的是父类引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换。多态自始至终都是子类对象在做变化

     

多态中成员的特点：

成员函数：编译看左边（父类），运行看右边

                               编译过程中，如果父类有此函数，编译通过，但是运行时，子类可能将此函数覆盖了，所以运行时看右边（子类）

成员变量：无论编译、运行都看左边

                静态：无论编译、运行都看左边（父类）

Object 类：是所有对象的直接或者间接“父类"object类中定义的是所有对象都具备的功能

         equals()方法：比较两个对象是否相等

         finalize()方法：垃圾回收机制（GC）来调用

         toString()方法：

抽象类：在多个类中，出现功能相同，但功能主体不同，可以进行向上抽取，这时，之抽取功能定义，而不抽取功能主体

            例如：多个类中都拥有学习方法，但学习的内容不同，这是可以向上进行抽取，将学习方法进行抽取

               

    

       抽象类的特点：

                    1、抽象方法只能定义在抽象类中

                    2、抽象类和抽象方法都必须被abstract关键字修饰

                    3、抽象方法只定义方法声明，并不定义方法的实现

                    4、抽象类不可以被创建对象（不可以被new）

                    5、只有子类继承抽象类，并覆盖抽象类中的所有抽象方法，抽象类才可以被实例化，否则该子类还是一个抽象类

                    6、抽象类只能单继承

                    7、抽象关键字abstract不能和：final，static，private 共存

             抽象类实例：

               模板设计方法：在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这是就将不确定的部分暴露出去，由该类的子类去完成，确定的部分定义成final，不让起去复写

                模板设计例子：

                   

接口：Interface

            接口的特点：

                    1、接口中的成员都是固定的：public

                            成员变量：public static final    是一个常量

                            成员函数：public abstract        是一个抽象方法

                        2、接口的出现将“多继承”通过另一种形式体现出来，即：“多实现”。

                            一个类在继承一个类的同时还能去实现接口

接口中的成员都是固定的：public

成员变量：publicstatic final     是一个常量

成员函数：publicabstract 是一个抽象方法

接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。一个类在继承一个类的同时还能去实现接口

类与接口的体现：

类与接口之间是实现关系，而且类可以基层一个类的同时实现多个接口

接口与接口之间是继承关系

代码体现：

abstract class Student<span style="white-space:pre"></span>//定义一个抽象类{abstract void study();<span style="white-space:pre"></span>//study抽象方法void sleep()<span style="white-space:pre"></span>//sleep方法{System.out.println("sleep");}}interface Running<span style="white-space:pre"></span>//定义一个接口{void run();<span style="white-space:pre"></span>//接口中的方法}class Lisi extends Student implements Running//继承和实现接口{void study()<span style="white-space:pre"></span>//复写父类中的study方法{System.out.println("study");}public void run()<span style="white-space:pre"></span>//复写Running接口中的run方法{System.out.println("run");};}class InterfaceDemo{public static void main(String[] args){Lisi ls = new Lisi();ls.sleep();ls.study();ls.run();}}

执行结果：

抽象类和接口的区别：

1、抽象类只能被继承，而且只能单继承

  接口需要被实现，而且可以多实现

     2、抽象类可以定义非抽象方法，子类可以直接继承使用

  接口中都有抽象方法，需要子类去实现

     3、抽象类使用的是 is a 关系（继承，子类is a）

  接口使用的是 like a 关系（接口，子类like a）

     4、抽象类的成员修饰符可以自定义

  接口中的成员修饰符是固定的，全都是public

     5、抽象类重定义的是体系结构的共性内容

  接口中定义的是对象的扩展功能