------- android培训、java培训、期待与您交流！ ----------
一：面向对象的概念
面向对象程序设计英文缩写为：OOP；Java子父James Gosling结合Interner背景设计了完成面向对象的java语言；而面向对象设计的过程就是抽象过程。
面向对象是一种认识事物的一种方式，,注重对事物整体的认知,这样就符合人类自然的思维习惯；所以作为程序员的我们要站在分类学家的角度去思考问题
在根据要解决的问题将事物进行分类，从中抽取出不同的类来在细化。
二：类与对象的关系
（一） 类：具有相同属性和方法的一组对象的集合；
（二） 对象就是实际存在的该实事物的个体，是具体的现实的，由此就可以用对象来描述客观事物的一个实体，对象又是由一组属性和方法构成。
比如“人类”就是一个类，那么具体的某个人“张三”就是“人类”这个类的对象，而“名字、年龄”等信息就是对象的属性，人的动作比如“吃饭、穿
衣”等就是对象的方法。总之类就是有相同特征的事物的集合，而对象就是类的一个具体实例。
因此，类和对象的关系就如同一个模具和用这个模具制作出的物品之间的关系，这种关系就是抽象和具体的关系，而每个类的作用就是创建对象；
在这个过程中就是在将一个类实例化的过程；而每个类的实例就是一个对象一个类可以生成多个对象；
（三）对象：是在java当中使用new关键字所产生的一个实体；这个实体在堆内存当中；
格式为： 类名 对象名=new 类名（）；
（四）java中要引用对象的属性和方法需要使用“.”操作符，其中对象名在圆点的左边，属性和方法在名称的圆点的右边。
三：面向对象的好处：
（一）面向对象的 思维方式是从人类考虑问题的角度出发，把人类解决问题的思维过程转变为理解的过程，使用“类”来模拟现实世界中的抽象概念，用“对象”
来模拟现实世界中的实体；从而在用计算机解决现实的问题。
（二）信息隐藏，提高了程序的可维护性和安全性，封装实现了模块化和信息隐藏。即将类的属性和行为封装在类中，这样保证了对他们的修改不会影响到其他对象，
有利于维护，在使用封装使得在对象外部不能随便访问对象的属性和方法，避免了外部错误对程序的影响，提高了安全性；
（三）提高了程序的可重用性，一个类可以创建对个对象实例，增加了重用性。
四：匿名对象
（一）匿名对象其实就是对象的简化形式；
（二）匿名对象两种使用情况分别为：
当对象方法仅进行一次调用的时候可以使用匿名对象；这样可以简化代码；如果对一个对象进行多个成员调用必须给这个对象起个名字。
匿名对象可以作为实际参数进行传递；
五 ：构造函数
（一）构造函数的特点：函数名与类名相同，不用定义返回值类型，不可以写return语句；
（二）作用：
（1） 对象一建立就会调用与子对应的构造函数，从而初始化对象；
（2）当一个类中没有定义构造函数，那么系统会默认给该类加入一个空参数的构造函数；如果自定义了构造函数系统就不会提供空的构造函数。
注意：
（1）默认构造函数的特点：
构造函数和一般函数在写法上有不同，在运行时也有不同，因为一般方法是在对象调用才执行，是给对象添加对象具备的功能。
一个对象建立，构造函数只运行一次，而一般方法可以被该对象调用多次。
（2）多个构造函数式以重载的形式存在的；
（3）什么时候定义构造函数呢？
当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。
（4）构造代码块与函数的区别：
构造代码块是给所有对象进行统一初始化，而构造函数式给对应的对象初始化；在构造代码块中定义的是不同对象共性的初始化内容。
六：this关键字是对一个对象默认引用，在每个实例方法内部都有一个this引用变量，指向调用这个方法的对象；
注意：
（1）因为this是在对象内部指代自身的引用，所以this只能调用实例变量，实例方法和构造方法；
（2）this不能调用类变量和类方法。
（3）this也不能调用局部变量。
（4）使用this关键字调用重载的构造方法，只能在构造方法中使用，并且是构造方法的第一条语句，因为初始化动作要先执行；
七 ;static关键字可以用来修饰 属性 方法 和代码块。
（一） static修饰的变量属于这个类所有，即由这个类创建的所有对象公用同一个static变量；通常把static修饰的属性和方法称为类属性（类变量）或
类方法；不使用static修饰的属性和方法，属于单个对象，通常称为实例属性（实例变量）或是实例方法；
（二）当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用，或是类名“.”静态成员；
（三）static关键字的特点：
（1）随着类的加载而加载，随着类的消失而消失，这说明他的生命周期最长；
（2）优先于对象的存在：
明确一点就是静态时先存在，对象后存在；
（3）被所有对象共享；
（4）可以直接被类名所调用。
（四）：实例变量和类变量的区别：
（1）存放位置：
类变量随着类的加载而存在于方法去中；
实例变量随着对象的建立而存在于堆内存中。
（2）生命周期：
类变量生命周期最长，随着类的消失而消失；
实例变量生命周期随着对象的消失而消失。
（五）静态使用注意事项：
（1）静态方法只能访问静态变量和静态方法；
（2）静态方法中不能定义this和super关键字；因为静态优先于对象的存在，所以静态方法中不可以出现this和super关键字；
（六）静态的好处与不足：
好处：对对象的共享数据进行单独空间的存储，节省空间，没有必要每一个对象中存储一份这样占用空间比较大，且还可以直接被类名直接调用；
不足处：生命周期过长，方位出现局限性，因为静态只能访问静态；
（七）特殊的主函数：
/*
* public static void main(String[] args)
* 主函数：是一个特殊的函数，作为程序的入口，可以被jvm调用。
*
* 主函数的定义：
* public：代表着该函数访问的权限是最大的。
* static：代表主函数随着类的加载就存在了；
* void:主函数没有具体的返回值；
* main:不是关键字，但是是一个特殊的单词，可以被jvm识别；
* (String[] args)：函数的参数，参数类型是一个数组，该数组的元素是字符串，字符串类型的数组；
*
* 主函数是固定格式的：jvm识别：jvm在调用主函数时传入的是new String[0];
*/
public static void main(String[] args) {
}
（九）静态代码块：格式为
static {
静态代码块中的代码；
}
（1）：特点：随着类的加载而执行，只执行一次；
（2）：如下代码在创建对象后的初始化顺序：
1：因为new用到了Test.class文件所以会先找到Test.class文件并加载到内存中；
2：执行该类中的static代码块，在给Test.class类进行初始化；
3：在到堆内存中开辟空间，分配内存地址；
4：在堆内存中建立对象的特有属性，并进行默认初始化；
5：对属性进行显示初始化；
6：对对象进行构造代码块初始化；
7：对对象进行对应的构造函数初始化；
8：将内存地址付给栈内存中的 t 变量。
public class Test {
private String name;
private int age;
Test(String name,int age){
this.name=name;
this.age=age;
}
public void setName(String name){
this.name=name;
}
public void speak(){
System.out.println(this.name+"...."+this.age);
}
}
//在main函数中初始化对象：Test t=new Test("lisi",20);
八：单例设计模式：解决一个类在内存中只存在一个对象；
（一）：作用
（1）为了避免其他程序过多的建立该类对象，先禁制其他程序建立该类对象；
（2）还为了让其他程序可以访问到该类对象，只好在本类中，自己的定义一个对象；
（3） 为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式；
（二）：如何实现呢：
（1）将构造函数是有化；
（2）在类中创建一个本类的对象。
（3）提供一个方法可以获得到该类的对象；
单例模式示例：
public static void main(String[] args) {
//在这里调用Single类的getInstance()方法得到Single类的对象
Single s=Single.getInstance();
Single ss=Single.getInstance();
//在这里使用得到的对象给setName赋值；
s.setName("张三");
//但在这里使用ss调用getName获取值打印的结果为 ：张三；说明这里只有一个对象；
System.out.println(ss.getName());
}
}
/*
* 单例设计模式1：饿汗式
*/
public class Single {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//私有化构造函数
private Single(){}
//创建一个类的对象并使用private , static修饰；将对象私有化；
private static Single s=new Single();
//写一个方法向外提供一个对外使用对象的方法；
public static Single getInstance(){
return s;
}
}
//单例设计模式2： 懒汉式，对象是方法被调用时才初始化，也叫做对象的延迟加载。
public class Single{
//创建一个类的对象并使用private , static修饰；将对象私有化但是对象的指向为null；
private static Single s=null;
//私有化构造函数
private Single(){}
//写一个方法向外提供一个对外使用对象的方法；
private static Single getInstance(){
//判断如果对象为空时就创建对象；不为空就直接返回原有对象
if(s==null){
s=new Single();
}
return s;
}
}