------- android培训、java培训、期待与您交流！ ----------
2，面向对象和面向过程都是一种思想。
3，面向过程强调的是功能行为。
4，面向对象是将功能封装进对象，强调具备了功能的对象。
5，面向对象是基于面向过程的。
面向对象的三个特征：封装，继承，多态。
类与对象的关系：
类就是对现实生活中事物的描述。
对象就是这类事物实实在在存在的个体。
映射到Java中，描述就是class定义的类（其实就是在描述属性与行为）。
具体对象就是对应java在堆内存中用new建立实体。
在java中，调用对象的方式：对象.对象成员
成员变量与局部变量的区别：
1，作用范围不同：成员变量作用于整个类中，局部变量作用于函数或语句中；
2，在内存中的位置不同：成员变量在堆内存中，因对象的存在才在内存中存在。局部变量存在栈内存中。
匿名对象
匿名对象是对象的简化形式。
匿名对象的两种使用情况：1，当对对象方法仅进行一次调用时；
2，匿名对象可以作为实际参数进行传递。
封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方向。
封装的好处：1，将变化隔离；2，便于使用；3，提高重用性；4，提高安全性。
封装的原则：将不需要对外提供的内容都隐藏提来，把属性都隐藏，提供对其访问的方式。
private:私有，权限修饰符，用于修饰类中的成员（成员变量，成员函数），私有只在本类中有效。
将属性私有化后，类以外即使建立了对象也不能直接访问，所以需要在类中提供对应的访问方式。
注意：私有仅仅是封装的一种表现形式。
之所以对外提供访问方式，是因为可以在访问方式中加入逻辑判断语句，对访问的数据进行操作，从而提高代码的健壮性。
构造函数特点：1，函数名与类名相同；
2，不用定义返回值类型；
3，不可以写return语句。
作用：给对象初始化。
注意：
1，默认构造函数的特点；
2，多个构造函数是以重载的形式存在的。
构造代码块
作用：给对象进行初始化。
特点：对象一建立就运行，而且优先于构造函数执行。构造代码块中定义的是不同对象共性的内容。
构造代码块与构造函数的区别：构造代码块是给所有对象统一初始化。
构造代码块是给对应对象初始化。
thisthis的特点：代表本类对象，代表它所在函数所属对象的引用。简单的说就是，哪个对象在调用this所在的函数，this就代表哪个对象。
this的应用：1，用于区分同名变量；2，用于构造函数之间进行互相调用。
注意：this语句只能定义在构造函数的第一行，因为初始化要先执行。
stitic关键字：用于修饰成员（成员变量和成员函数）。被修饰后的成员具备以下特点：
1，随着类的加载而加载。
2，优先于对象存在。
3，被所有对象所共享。
4，可以直接被类名调用。
注意：1，静态方法只能定义静态成员，非静态方法既可以访问静态，也可以访问非静态。
2，静态方法不可以写this，super关键字。
3，主函数是静态的。
实例变量和类变量的区别：
1，存放位置：类变量随着类的加载而存在于方法区中，实例变量随着对象的建立而存在于堆内存中。
2，生命周期：类变量生命周期最长，随着类的消失而消失。实例变量生命周期随着对象的消失而消失。
什么时候使用静态？
1，当对象存在共享数据时，该静态被对象修饰（即定义静态变量/类变量）
2，当功能内部没有访问到非静态数据时（对象中的特有数据），那么该功能可以定义成静态。
将方法静态后，可以方便使用，但该类还是可被以其他程序建立对象。为了更严谨，强制让该类不能建立对象，可以通过将构造函数私有化来完成。
静态代码块：
格式：
static
{
静态代码块中的执行语句；
}
特点：随着类的加载而加载，只执行一次，并优先于主函数用于给类进行初始化。
对象初始化过程：如 Person p = new Person(zhangsan,20);
1,因为new用到了Person.class，所以会先找到Person.class文件并加载到内存中。
2，执行该类中的static代码块，如果有的话，给Person.class初始化。
3，在堆内存中开辟空间，分配内存地址值。
4，在堆内存中建立对象的所有属性，并进行默认初始化。
5，对属性进行显示初始化。
6，对对象进行构造代码块初始化。
7，对对象进行对应的构造函数初始化。
8，将内存地址值赋给栈内存中的p变量。
单例设计模式：作用是用来解决一个类在内存中只存在一个对象。
用代码体现位：
1.1 将构造函数私有化；
1.2 在类中创建一个私有并静态的对象；
1.3 提供一个方法可以获取该对象。
用法：
对于事物，应该怎样描述还是怎样描述。当需要将事物的对象保证在内存中唯一时，就将以上三步加上即可。
单例设计模式的两种形式：
3.1 饿汉式（高效，安全，多用于开发）
3.2 懒汉式（不常用，多用于面试）
饿汉式：
class Single01
{
private Single01(){};
private static Single01 s = new Single01();
public static Single01 getInstance()
{
return s;
}
}
class Demo
{
public static void main(String[] args)
{
Single01 s1 =Single01.getInstance();//s1,s2的引用指向同一个对象。
Single01 s2 =Single02.getInstance();
}
}
懒汉式：
class Single02
{
private static Single02 s =null;
private Single(){};
private static Single02 Instance()
{
if(s==null)
{
sychronized (Single02.class)//双重判断，提高了安全性。
{
if(s==null)
s = new Single02;
}
}
return s;
}
}
class Demo
{
public static void main(String[] args)
{
Single01 s1 =Single01.getInstance();//只有调用getInstance方法时，对象才建立。
Single01 s2 =Single02.getInstance();
}
}
继承：1，提高了代码的复用性。2，让类于类之间产生了关系，有了这个关系，才有了多态的特性。 父类出现后，类成员的特点：
1，变量：如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量用this，要访问父类中的同名变量，用super。
this代表本类对象的引用。super代表父类对象的引用。
2，子父类中的函数
当子类出现和父类一样的函数时，当子类对象调用该函数，会运行子类函数的内容。这种情况是函数的另一种特性：重写（覆盖）。
覆盖的注意事项：
1，子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。
2，静态只能覆盖静态。
3，子父类中的构造函数
在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类构造函数默认第一行有一条隐式的语句super（）；
该语句会访问父类中的构造函数，而且子类中所有构造函数默认第一行都是super（）；
final关键字
1，final可以修饰类，方法，变量。
2，final修饰的类不可以被继承。
3，final修饰的方法不可以被覆盖。
4，final修饰的变量是一个常量，只能被赋值一次。
5，内部类只能访问被final修饰的局部变量。
抽象类：当多个类中出现相同功能，但功能主体不同，这时可以进行向上抽取。这时，只能取功能定义，而不是功能主体。也就是这些不明确的部分，
也是该事物的功能，需要明确出现，但无法定义主体。
特点：
1，抽象方法一定在抽象类中。
2，抽象方法和抽象类必须被abstract关键字修饰。
3，抽象类不可以用new创建对象，因为调用抽象方法没意义。
4，抽象类中的方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是抽象类。
特殊之处：抽象类中可以不定义抽象方法，这样仅仅是不让该类创建对象。
模板方法：在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分。那么这时就将不确定的部分暴露出去，由该类的子类去完成。
interface{ }
接口中的成员修饰符是固定的：
成员变量：public static final
成员函数：public abstract
接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。
接口的特点：
接口是程序的功能拓展。
接口可以用来多实现。
类与接口之间是实现关系，而且类可以继承一个类的同时，实现多个接口。
接口与接口之间可以有继承关系。
多态：某一类事物的多种表现形式。例如：动物中的狗，猫。
猫这个对象对应的类型是猫类型： 猫 x = new 猫（）；
同时猫也是动物的一种，也可以把猫成为动物： 动物 y = new 猫（）；
动物是猫和狗具体事物中抽取出来的父类型。
多态的体现：1，父类型引用指向了子类型对象；2，父类引用也可以接受自己的子类对象。
多态的好处：大大提高程序的拓展性。
多态的前提：必须是类与类之间有关系，要么继承，要么实现。
多态的局限性：只能使用父类的引用访问父类中成员。
多态成员函数（非静态）的特点：
在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，否则编译失败。
在运行期间：参阅对象所属的类中是否有调用的方法。
多态中成员变量，静态成员函数的特点：
无论编译和运行，都参阅左边（引用型变量所属的类）。
object：是所有对象直接或者间接父类。该类中定义的肯定是所有对象都具备的功能。
内部类：将一个类定义在另一个类里面，对里面那个类就称为内部类（内置类，嵌套类）。 访问特点：内部类可以直接访问外部类中的成员，包括私有成员。而外部类要访问内部类中的成员，必须要建立内部类的对象。
异常 1、异常：就是程序在运行时出现不正常情况。
2、异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。
其实就是java对不正常情况进行描述后的对象体现。
3、程序可能出现的错误或问题
a、用户输入错误导致的异常：如用户不正常使用程序，输入一些非法参数
b、设备硬件等发生的错误：如硬盘损坏等
c、物理限制：如存储空间不足等
d、代码错误：在程序编写的方法可能不正确，返回错误参数等。
异常有两种：
1、编译时被检测异常
该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。该异常被标识，代表着可以被处理。
2、运行时异常(编译时不检测)
在编译时，不需要处理，编译器不检查。该异常的发生，建议不处理，让程序停止。需要对代码进行修正。
如：RuntimeException以及其子类。
异常的处理
1、 java提供了特有的语句进行处理。
try
{
需要被检测的代码。
}
catch（异常类 变量）
{
处理异常的代码；（处理方式）
}
finally
{
一定会执行的语句；
}
有三个结合格式：
a、try
{
}
catch ()
{
}
b、try
{
}
finally
{
}
c、try
{
}
catch ()
{
}
finally
{
}
throw和throws的区别于用法：
throw定义在函数内，用于抛出异常对象。
throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。
当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，否则编译失败。
注意：RuntimeException除外。也就说，函数内如果抛出的RuntimeExcpetion异常，函数上可以不用声明。
自定义异常：因为项目中会出现特有的问题，而这些问题并未被java所描述并封装对象。
所以对这些特有的问题可以按照java中的面向对象思想。将特有的问题，进行自定义的异常封装。
定义类继承Exception或者RuntimeException
1，为了让该自定义类具备可抛性。
2，让该类具备操作异常的共性方法。
异常的注意事项
1、问题在内部被解决就不需要声明。
2、catch是用于处理异常。如果没有catch就代表异常没有被处理，如果该异常是检测时异常。那么必须声明。
3、在子父类覆盖时：
a,子类抛出的异常必须是父类的异常的子类或者子集。
b,如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。
包（package）包的作用与特点：1，对类文件进行分类管理；
2，给类文件提供多层命名空间；
3，写在程序文件第一行；
4，类名的全称是： 包名.类名；
5，包也是一种封装形式。
总结：包与包之间进行访问，被访问的包中的类以及类中的成员需要public修饰。
不同包中的子类还可以直接访问父类中被protected权限修饰的成员。
包与包之间使用的权限只有两种：public，protected。
关于权限总结：
权限： public protected default private
同一类中 ok ok ok ok
同一包中 ok ok ok
子类 ok ok
不同包中 ok