java面向对象

总结： Java是面向对象的编程语言，Java面向对象有三大特点：a.封装性；b.继承性；c.多态性。
一、封装性。
1.类可以将类的属性和方法封装到一起。（把属性和方法封装到一起的目的是为了更好的调用属性和方法。）
要想使用class里面的attribute和method，就必须创建class的instance。（怎么去创建instance呢？）
instance的创建方法：
使用new关键字+class的构造方法。（创建好了class的instance再怎么去调用class中的attribute和method呢？）
new class（）.attribute 调用class的属性
new casse（）.method 调用class的方法

这用做就有一个问题了，因为这样调用方法和属性都是一次性的，调用完了，就被销毁了，为了实现多次调用有不需要去重复创建class的instance
我们该怎么去做咧？不难想到，使用应用变量。定义一个应用变量就可以不用重复创建instance，而可以多次去调用class的attribute和method。

创建引用变量的方法：
引用变量类型 引用变量 （句引用柄）
引用变量= class的instance
引用变量调用class的method和attribute的方法：
引用变量.attribute 调用attribute
引用变量.method 调用method

应为一个class可以new出多个instance，那么是不是这些instance就都相等了呢？
又怎么去比较instance呢？
Java中提供了两种方案。一是用“==”运算符，二是用equals（）方法。
经过两种方案的比较，不难发现，instance是不相等的，只是内容相等，这又是为什么咧；
通过instance在内存中的变化，不难发现，Java在创建instance时都为其分配了不同的内存。

2.类封装性的实现。（不难发现，我们只要创建了class的instance，就可以在其他class中随意的调用attribute和method，这样会带来数据的混乱和很多麻烦，
怎么去实现和解决这个问题咧？）
其实我们只要把class中的attribute和method的私有化，就可以解决这个问题了。
怎么私有化attribute合method呢。这里，我们要用到关键字private。
private使用方法：
private attribute 使attribute私有化
private method 使method私有化

上面这样做确实解决了数据混乱和很多麻烦，但在实际应用中，我们要经常要在别的类中调用class的attribute和method，怎么解决想不带来数据混乱，又可以
访问attribute和method呢？

要解决上面的问题，我们就要在class中建一个public method，通过这个共有的method去实现对外的访问，通常每个class中的attribute都可以创建一个get（）和
set（）方法。
这样的方式就实现了类良好封装性。
经验：在程序设计中要尽可能的做到强内聚（许多功能尽量在类的内部独立完成），弱耦合（提供外界尽量少的方法去条用）

前面在创建class的instance是我们用到了“class（）”不是很了解，只是记住了。
为什么要这样表示咧，这样表示是什么意识咧？学了class的构造方法，我们就一切都清楚了
class的构造方法与其他的类的方法有什么不同吗，为什么要单独把它提出来讲咧。我想在Java设计时，它就有单独的意义存在着。
构造方法的特点：
a.它具有与类相同的名称
b.它不含返回值
c.它不能在方法中用return语句返回一个值。
构造方法有什么独特的作用吗？我们会有这样的疑问，
构造方法的作用：当一个class被instance时，它可以完成class的初始化，只用在构造方法中增添相应的代码
构造方法有两种类型的，一种是不带参数的，它是Java默认的类的构造方法，当一个类中没有声明构造方法时，在创建instance，Java就用这个构造方法。
另一种是带参数的，当一个class中有没有申明不带参数的构造方法，那么在创建instance时，Java就不会把不带参数的构造方法当做默认的了，但是在创建
instance时，一定要记得给构造方法赋值，要不程序就会报错。（按照历来的经验，一般在创建带参数的构造方法时，也创建一个不带参数的构造方法，这样就避免了
在创建instance时，忘记给构造方法赋值后程序报错）

前面我们在学对象实例化（instance）时，提到了引用句柄，这里我们还需要学习一下this引用句柄。关于this引用句柄，我们用明吧this到底代表着什么。
this代表的是当前所属对象的引用句柄。
学习this引用句柄，用四种情况：
1.在同一个类中，一个对象中的成员方法可以引用另一个对象的成员，在这种情况中用this与不用this的效果是一样的（也就是在同一类中用，用不用this都一样）
2.当构造方法中的形式参数名与类中的成员变量名是一样时，要想把外界参数传递给成员变量，我们可以使用this。
3.this可以作为对象的句柄，作为参数区传递。
4.在同一个类中的不同构造方法中，我们可以在一个构造方法中用this（参数列表）去调用另一个构造方法。

前面我们学习了句柄，句柄是和instance相关联的，如果一个instance没用和句柄相关联，那么这个instance会变为垃圾，由Java的垃圾处理机制去处理，学习Java的
垃圾处理我们得掌握两个方法一个是finalize（），另一个是Systerm.gc（）
finalize（）{}的作用在于，当对象变为垃圾时，执行{}里面的内容，但是Java垃圾处理机制，是Java自己调用的不是有程序员控制的，这就导致垃圾产生式，finalize（）
方法不一定会被唤醒。
为了解决上面的问题，我们就得在程序中加入Systerm.gc()方法，调用这个方法可以强制起到垃圾回收器来回收垃圾。

看了对象的成员变量，接下来我们研究一下对象的成员方法，降到成员方法，我们就得了解成员方法的参数传递，降到成员方法，我们得分两个方面进行研究：第一个是基本
数据类型的参数传递，第二个是引用类型的参数传递。
1.基本数据类型的参数传递；
对于基本数据类型的参数，调用方法中形式参数，就相当于定义了方法中的局部变量，当方法被调用完后，变量就被释放了，不会影响程序中同名的局部变量。
2.引用数据类型的参数传递；
对于引用类型，如果是将对象传递给了方法，那么方法就会改变其对象的值，如果方法中重新创建了一个实例对象，那么所改变的值只是方法本生的局部变量。
对于数组类型的参数传递，其情况和引用类型的情况是一样的。

我们在编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上的对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象，
其方法才可以被外部调用。
有时候，我们希望无论是否产生了对象或无乱产生了多少对象的情况下，某些特定的数据在内存空间里只有一份。
要解决上面这种需求，我们得掌握好java中static关键字：掌握它要从三个方面去学，第一个是静态变量，第二个是静态方法，第三个是静态代码块，
1.静态变量：
静态变量只在类被创建时才会被加载，只要类存在，static变量就存在，并被个实例对象所共享。典型案例：统计程序中一共产生了多少某类的实例对象。
2.静态方法：
同静态成员变量一样，静态方法可以用类名直接访问静态成员方法，也可以用类的实例对象来访问静态成员方法，还可以在类的非静态的成员方法中像访问其他非静态成员
一样去访问这个静态方法。
使用静态方法应当注意以下几点：
1.在静态方法里只能调用同类中的静态成员（包括成员变量和成员方法），而不能访问类中的非静态
成员。这是应为非静态成员只有创建了类的实例对象才可以使用，二类的静态方法在使用前事不需
创建实例对象。
2.静态成员不能以任何方式使用this和super关键字，这是因为当静态方法被调用时，this所引用的对象
更本就没有产生。
3.main（）方法时静态的

3.静态代码块：
一个类可以使用不包含在任何方法体中的静态代码块，静态代码块，在类被创建时被加载，并且只加载一次，静态代码块用于实现类的初始发。

学到这里，我们也积累了一点经验了，学到这里我们也可以看看前人总结出来的经验了，单态设计模式，就是Java中很重要的一种设计思想。
何谓单态设计模式了，单态设计模式用什么用途了？许多的疑问油然而来。
单态设计模式是指：采取一定的方法保证整个系统中，对某个类只存在一个对象实例，并且该类只提供一种方法去取得对象的实例。
如果要让类在Java虚拟机中只有一个对象，那么久应当把类的够造方法设为私有，这样，在外部就不能用new关键字产生对象实例了，但在类的内部
任然可以创建对象实例，外部如果想要访问类的对象实例，在内部就必须提供一个静态方法。

在前面的学习中，我们可能碰到在一个类里面还有其他的类，在一个方法里，也能定义一个类，下面我们在来研究一下内部类（套嵌类）套嵌类分为两种情况
一种是定义在一个类的内部，另一种是定义在一个方法的内部。
1.定义在一个类内部的类。
内部类和普通类没有什么区别，它可以直接访问它内部类的所用方法和成员变量，就像外部类非static成员的功能一样，和外部类不同的是类不类可以被申明为private或protected
如果用static修饰一个内部类，这个类就相当于是一个外部定义的类，所以static的内部类中可以声明static成员，但是，非static的内部类的成员是不能申明为static的。static
的内部类不能再使用外层封装类的非static的成员变量
内部类的作用：当一个类中的程序代码要用到另外一个类的实例对象，而另外一个类中的程序代码又要访问第一个类中的成员，将另外一个类做成第一个类的内部类，程序代码就要容易
编写的多，这样的情况在世界应用中非常之多。
2.定义在一个方法内部的类。
在方法中定义的内部类只能访问方法中的final类型的局部变量，一位用final定义的局部变量相当于是一个常量，它的生命周期超出方法运行的生命周期。

二、继承性。
学到这这里，我们有很多疑问，什么事继承，继承有什么做用呢
通过字面不难理解，在Java中，继承就是子类继承父类的成员变量和成员方法（父类的构造方法除外）
那么，继承有什么用列？
通过继承可以简化类的定义，不用再去重复写代码了。
那么继承有什么特点呢？
1.通过继承可以简化类的定义。
2.java只支持单继承，不允许多重继承。在java中，一个子类只有一个父类，不允许一个类直接继承多个类，但一个类可以被多个类继承。
3.可以有多层继承，即一个类可以继承某一个类的子类，
4.子类继承父类所有的成员变量和成员方法，但不继承父类的构造方法。在子类的构造方法中可以用super（参数列表）调用父类的构造方法。
5.如果子类的构造方法中没有显示地调用父类构造方法，也没有使用this关键字条用重载的其他构造方法，则在产生子类的实例对象时，系统默认调用父类无参数的构造方法。
（如果子类构造方法中没有显示地调用父类构造方法，而父类中又没用无参数的构造方法，则编译出错。所以，我们在定义类时，只要定义了有参数的构造方法，通常都还
需要定义一个无参数的构造方法。）
6.子类可以根据需要对父类的方法进行改造（方法的覆盖或叫方法才重写）覆盖的方法必须和被覆盖的方法具有相同的名称、参数和返回值。
（覆盖方法时，不能使用比父类中被覆盖的方法更严格的访问权限。例如：父类中的方法时public的。子类的方法就不能是private的。）
7.如果子类中像调用被覆盖的父类的方法，可以通过关键字super.方法名。

学到这里，我们可能会留意到final这样一个关键字，不由得产生了许多疑问，
final，在java中到底是干什么用的呢？
1.在java中申明类、属性和方法时，可以使用关键字final来修饰。
2.final 标记的类不能被继承。
3.final标记的方法不能被子类重写。
4.final标记的变量（成员变量或局部变量）即成为常量，只能赋值一次。
5.方法中定义的内部类，只能访问方法中用final修饰的局部变量。

学完了final，我们还会碰到，abstract，这样一个关键字，它到底又是怎么用的呢？
带着这样的一个疑问，我们先来看看抽象类的这样一个概念。
在java中，类中可以定义一些不含方法体的方法，它的方法实现，留给它的子类根据具体的情况去实现，像这样的方法我们称它为抽象方法，包含一个或多个抽象方法的类
我们称它为抽象类，抽象方法我们用abstract来修饰，抽象类，我们也用abstract来修饰。
哦abstract，是表式抽象方法和抽象类的哦，明白了这一点，我们可能，还想问抽象类和抽象方法到底有什么用列？
不难想到，抽象类的存在主要是为了子类提供具体方法的实现的。
学到这里，我们要注意几点：
1.抽象类和抽象方法必须用abstract来修饰。
2.抽象类不能被实例化。
3.抽象方法只需申明，而不需要实现。
4.抽象类的子类必须覆盖抽象类中所用的抽象方法，才可以被实例化。

学到这里，我们会想，要是一个类中所用的方法都是抽象的，那这个类还是不是叫抽象类了呢？
这里我们就引出了接口的概念，什么事接口了，不难想到，接口就是抽象方法和常量值定义的集合。从本质上讲，接口就是一个特殊的抽象类。
学到这里，我们应该注意几点：
1.实现一个接口就是要实现该接口的所用抽象方法。（抽象类除外）
2.接口中的方法都是抽象方法，
3.多个无关的类可以实现一个接口，一个类可以实现多个无关的接口。

三、多态性。