java之面向对象(一)

主要知识点：

1. 什么叫面向对象
2. 类
3. 构造方法
4. static与类的加载顺序
5. 匿名对象
6. this关键字
7. 封装
8. 访问权限修饰符
9. 类的设计分析
10. 继承
11. 子类访问父类和方法覆写
12. super关键字
13. 多态
14. 引用变量类型转换

• 什么叫面向对象

面向对象：把数据和对数据的操作方法放在一起，作为一个相互依存的整体——对象。对同类对象抽象出其共性，形成类。类中的大多数数据，只能用本类的方法进行处理。类通过一个简单的外部接口与外界发生关系，对象与对象之间通过信息进行通信。程序流程由用户在使用中决定。面向过程：自顶向下顺序执行，逐步求精，其程序的结构按功能划分若干个模块，这些模块形成一个树状的结构，各模块之间的关系尽可能的简单，在功能上相对独立；每一个模块都是由顺序，选择和循环三种基本结构来组成；其模块化的具体方法是使用子程序。程序流程在写程序中就已决定。

面向对象的特点：

1. 将复杂的事情简单化。
2. 面向对象将以前过程中的执行者变成了指挥者。
3. 面向对象这种思想是符合现代人们思考习惯的一种思想。

• 类

类是java语言最小的变成单位，也是设计和实现java程序的基础。

类是一组事物共性的特征和功能的描述，类是一组事物的总体描述，是按照面向对象技术设置的最小单位，也是组成项目的最基本的模块。类的概念是抽象的，类似于建筑设计中的图纸，是对于实现需要代表的具体内容的抽象，类只包含框架结构，而不包含具体的数据。所以类代表的是总体，不是代表某个特定的个体。

类是抽象的，对象是具体的。

• 构造方法

构造方法：用来构造类的实例（每一个类都默认有一个无参的构造方法，得使用new调用）

字段：类或对象所包含的数据，对类状态的一种描述。

方法：类或对象的特征或行为。

作用：给类中的字段进行初始化，可以用来创建对象。

特点：1.方法名和类名相同，不用定义返回值，不需要写return语句。

注意：多个构造方法是以重载的形式出现的。

• static与类的加载顺序

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

特点：

1. 被所有的对象所共享。
2. 可以直接被类名调用。
3. 随着类的加载而加载。
4. 优先于对象存在。

弊端：

1. 有些数据是对象特有的数据，是不可以被静态修饰的，因为那样的话，特有的数据会变成共享的数据。这样对事物的描述就出现了问题，在定义静态时要明确是否被共享。
2. 静态方法只能访问静态成员，不可以访问非静态成员，因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。
3. 静态方法中不能使用this和super关键字，因为this代表对象，而静态的时候可能没有对象，所以this无法使用。
4. 主函数是静态的。

什么定义静态的成员呢？或者说，在定义成员的时候，到底要不要被静态修饰？

　　成员变量。（数据共享的时候静态化）

　　　　该成员变量的数据是否是所有对象一样：

　　　　如果是，那么该变量需要被静态修饰，因为是共享数据。

　　　　如果不是，那么就说这是对象的特有数据。

　　成员函数。（方法中没有调用特有数据的时候就定义成静态）

　　　　该函数内是否访问了特有数据。

　　　　如果有不能被修饰，没有则需要被静态修饰。

成员变量和静态变量的区别？

1. 成员变量所属于对象也成为实例变量。静态变量所属于类，也被称为类变量。
2. 成员变量存在于堆内存中。静态变量存在于方法区中。
3. 成员变量随着对象创建而存在，随着对象被回收而消失。静态变量随着类的加载而存在，随着类的消失而消失。
4. 成员变量只能被对象所调用，静态变量可以被对象调用，也可以被类名调用。

　　所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据。

静态的注意：静态的生命周期很长。

静态代码块：就是一个有静态关键字标示的一个代码块区域，定义在类中。

作用：可以完成类的初始化，静态代码块随着类的加载而执行，而且只执行一次（new 多个对象就只执行一次）。

如果和主函数在同一个类中，优先于主函数执行。

静态代码块，构造代码块和构造函数的区别？

　　静态代码块：用于给类初始化，类加载时会被加载执行，只加载一次。

　　构造代码块：用于给对象初始换，只要创建对象该不菲就会被执行，且优先于构造函数。

　　构造函数：给对应对象初始化，建立对象时，选择相应的构造函数初始化对象。

　　创建对象时，三者被加载执行顺序：静态代码块>构造代码块>构造函数

什么时候会加载类？

　　使用类中的内容时加载：有三种情况。

　　　　1.创建对象，new StaticCode（）；

　　　　2.使用类中的静态成员 StaticCode.num = 9 ，StaticCode.show（）；

　　　　3.在命令行中运行 java StaticCodeDemo

类所有内容加载顺序和内存中的存放位置

　　利用语句分析

Person p = new Person("zhangsan",20);

　　　　该句话所做的事情：

　　　　1.在栈内存中，开辟main函数空间，建立main函数的变量p

　　　　2.加载类文件：因为new要用到Person.class，所有要先从硬盘中找到Person.class类文件，并加载到内存中。

　　　　　　加载类文件时，除了非静态成员变量（对象的特有属性）不会被加载，其他的都会被加载。

　　　　　　记住：加载，是将类文件中的一行行内容加载到内存中，并不会执行任何的语句。加载时期，即使有输出语句也不会执行。

　　　　　　　　静态成员变量（类变量）　　 ----------》方法区的静态部分

　　　　　　　　静态方法 　　　　　　　　　----------》方法区的静态部分

　　　　　　　　非静态方法（包括构造函数） ----------》方法区的非静态部分

　　　　　　　　静态代码块　　　　　　　　-----------》方法区的静态部分

　　　　　　　　构造代码块       　　　　　   ----------》方法区的静态部分

　　　　　　　　注意：在Person.class文件加载时，静态方法和非静态方法都会加载到方法区中，只不过要调用非静态方法的时候要先实例化一个对象。

　　　　　　　　　　对象才能调用非静态的方法，如果让类中的所有非静态方法都随着对象的实例化而建立一次，那么会消耗大量的内存资源。

　　　　　　　　　　所以才会让所有的对象共享这些非静态方法，然后用this关键字指向调用非静态方法的对象。

　　　　3.执行类中的静态代码块，如果有的话对person.class进行初始化。

　　　　4.开辟空间：在堆内存中开辟空间，分配内存地址。

　　　　5.默认初始化：在堆内存中建立对象的特有属性，并进行默认的初始化。

　　　　6.显示初始化：对属性进行显示初始化。

　　　　7.构造代码块：执行类中的构造代码块，对对象进行构造代码块初始化。

　　　　8.构造函数初始化：对对象进行对应的构造函数初始化。

　　　　9.将内存地址赋值给栈内存中的变量p

p.setName("lisi");

　　　　1.在栈内存中开辟setName方法的空间，里面有：对象的引用this，临时变量name

　　　　2.将p赋值给this，this就指向了堆中调用该方法的对象。

　　　　3.将“lisi”赋值给临时变量name

　　　　4.将临时变量的值赋给this的name

Person.showCountry();    

　　　　1.在栈内存中，开辟showCountry（）方法的空间，里面有：类名的引用Person。

　　　　2.Person指向方法区中的Person类的静态方法区的地址。

　　　　3.调用静态方法区中的country，并输出。

　　　　注意：要想使用类中的成员，必须调用。通过什么调用？有：类名，this，super

 1 class Person
 2 {
 3     private String name;
 4     private int age=0;
 5     private static String country="cn";
 6     Person(String name,int age)
 7     {
 8         this.name=name;
 9         this.age=age;
10     }
11     static
12     {
13         System.out.println("静态代码块被执行");
14     }
15     { System.out.println(name+"..."+age);    }
16     public void setName(String name)
17     {
18         this.name=name;
19     }
20     public void speak()
21     {
22         System.out.println(this.name+"..."+this.age);
23     }
24     public static void showCountry()
25     {
26         System.out.println("country="+country);
27     }
28 }
29 class StaticDemo
30 {
31     static
32     {
33         System.out.println("StaticDemo 静态代码块1");
34     }
35     public static void main(String[] args)
36     {
37         Person p=new Person("zhangsan",100);
38         p.setName("lisi");
39         p.speak();
40         Person.showCountry();
41     }
42     static
43     {
44         System.out.println("StaticDemo 静态代码块2");
45     }
46 }

输出结果：
      StaticDemo 静态代码块1
      StaticDemo 静态代码块2
      静态代码块被执行
      null...0          //构造代码块
      lisi...100        //speak()
      country=cn        //showCountry()

• 匿名对象

特点：对方法或者对象只进行一次调用，可作为实际参数进行传递，只在堆里面开辟存储区域。只能使用一次，使用完就被销毁了。

new Person();                  //表示匿名对象,没有名字的对象
new Person().age = 17;    //使用一次之后就被销毁了
        

• this关键字

this ：代表对象，就是所在函数和所属对象的引用。

this到底代表什么呢？

哪个对象调用了this所在的函数，this就代表哪个对象，就是哪个对象的引用。

开发时，什么时候使用this呢？

在定义功能时候，如果该功能内部使用到了调用该功能的函数，这时就用 this 来代表这个对象。

this还可以用于构造函数之间的调用。

注意：用this调用构造函数，必须定义在构造函数的第一行，因为构造函数是用于初始化的，所以初始化动作一定要执行，否则编译失败。

• 封装

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

好处：将变化隔离，便于使用，提高重用性和安全性。

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

封装机制在程序中的体现是：把描述字段的状态用字段表示，描述对象的行为用方法表示，把字段和方法定义到一个类中，并保证外界的字段不能任意的更改其内部的字段值，也不允许任意的调动其内部的功能方法。

• 访问修饰符

• 继承

继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

好处：1.提高了代码的复用性。2.让类和类之间产生了关系，提供了另一个特征多态的前提。

父类的由来：其实是由多个类不断的向上抽取共性的内容而产生的。

java中只支持单继承，但是保留了这种多继承的机制，进行改良。

java为什么不支持多继承呢？

　　因为当一个类同时继承两个父类时，两个父类中有相同的功能，那么子类对象调用该功能的时候，运行哪一个呢？因为父类方法中存在方法体。

　　java支持多重继承，A继承B，B继承C，C继承D。

　　多重继承的出现，就有了继承体系，体系中的顶层父类是通过不断的向上抽取而来的，它里面定义了该体系最基本最共性内容的功能。

　　所以一个体系想要被使用，直接查阅该体系中顶层父类的功能就能知道该体系最基本的用法，那么想要使用一个体系的时候，需要建立对象。建议建立最子类的对象，因为最子　　　　类不仅可以使用父类的功能，还可以使用子类特有的一些功能。

　　简单说，对于一个继承体系的使用，查阅顶层父类中的内容，创建最底层子类的对象。

子类实例化的过程

在继承操作中，对于子类对象实例化。子类对象在进行实例化之前必须首先调用父类的构造方法之后，在调用自己的构造方法。

• super（）关键字和调用父类构造方法

子父类出现后，类中的成员有哪些特点：

1.成员变量

　　当子父类出现一样的属性时，子类类型的对象，调用该属性，值是子类的属性值。

　　如果想要调用父类中的属性值，需要使用一个关键字super（）。

　　this 代表是本类类型的对象的引用。

　　super 代表子类所属父类中的内存空间的引用。

　　注意：子父类中通常是不会出现同名成员变量的，因为父类中只定义了，子类中就不用在定义了，直接继承过来就行。

2.成员函数

　　当子父类中出现一模一样的方法时，建立子类对象会运行子类中的方法，好像父类中的方法被覆盖掉一样。这个特性叫覆盖（复写，重写）

　　什么时候使用覆盖呢？当一个类的功能内容需要修改时，可以通过覆盖来实现，

3.构造函数

　　发现子类构造函数运行时，先运行了父类构造函数，为什么呢？

原因：子类的所有构造函数的第一行，其实都有一条隐身的语句super（）

super（）表示父类构造函数，并会调用于参数相对应的父类中的构造函数，而super（）是在调用父类中空参数的构造函数。

为什么子类对象初始化的时候都需要调用父类的函数？

因为子类继承父类，会继承父类这中的数据，所以要看父类是如何对自己的数据进行初始化的，所以子类在进行初始化时，先调用父类构造函数。

注意：子类中所有的构造函数都会访问父类中空参数的构造函数，因为每一个子类的构造内第一行都有默认的语句super（）。

　　　如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super（）语句指定要访问的父类中的构造函数。

　　　如果子类构造函数中用this来指定调用自己的构造函数，那么被调用的构造函数一样会访问父类的空参构造函数。

问题：super()和this（）是否可以同时出现在构造函数中？

　　两个语句都只能定义在第一行里，所以只能同时出现一个。

super（）或者this（）为什么一定要定义在第一行？

　　因为super（）和this（）都是调用构造函数，构造函数用于初始化，所以初始化动作要先完成。

继承的细节：

什么时候使用继承呢？

　　当类与类之间存在着所属关系时，才具备了继承的前提，a是b的一种，a继承b，狼是犬科中的一种，所属关系 “is a”。

　　注意：不仅仅是为了获取其他类中的已有成员进行继承。

判断所属关系，简单看，如果继承后，被继承中的类中的功能，都可以被子类所具备，那么继承成立，如果不是，不可以继承。

在方法覆盖时，要注意两点。

　　1.子类覆盖父类时，要必须保证，子类方法的权限必须大于等于父类方法的权限才可以继承，否则，编译失败。

　　2.覆盖时，要么都静态，要么都不静态。（静态只能覆盖静态，不静态只能覆盖不静态）

• 多态

函数本身就具备多态性，某一种事物有不同的具体的体现。

体现：父类引用或者接口的引用指向了自己的子类对象。

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

多态的弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中的具体方法，不可以访问子类中的特有方法。

多态的前提：1.必须要有关系，比如继承或者实现。 2.通常会有覆盖操作。

多态是一种运行期的行为，不是一种编译期的行为。

编译时的类型由声明该变量时使用的类型决定，运行时的类型有实际赋给变量的对象决定，如果编译时的类型和运行时类型不同，就出现了多态。

实现多态的机制

父类的引用变量可以指向子类的实例对象，而程序调用的方法在运行时期才能动态的绑定，就是引用变量所指向真正实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。

如果想用子类对象的特有方法，如何判断对象是哪个具体的子类类型呢？

可以通过一个关键字：instanceof    //判断对象是否实现了指定的接口或继承了指定的类。

格式 <对象 instanceof 类型> ，判断一个对象是否所属于指定的类型。

Student instanceof Person = true;//student 继承了 person 类