一面向对象概念
1 理解面向对象
(1) 面向对象是相对面向过程而言。
(2)面向对象和面对过程都是一种思想。
(3)面向过程强调的功能行为。
(4)面向对象将功能封闭成对象，具备了功能的对象。
(5)面向对象是基于面向过程的。
(6)面向对象的三个特征：封装，继承，多态。
2面向对象要点
(1)相对于过程，面向对象使问题更加简单化。
(2)对象不只是指人，万物皆可为对象。
(3)面向对象使执行者变为指挥者。
(4)开发时，先找对象，再找功能，找到了直接用。
(5)没有对象时，创建对象再用。
2类与对象的关系
(1)类：对现实生活中的事物的描述 (对象的抽象)
(2)对象：就是这类事物实实在在的个体(类的实例)
3.main函数
public static void main(String[] args)
public :代表着该函数的访问权限是最大的。
static :主函数是静态的，代表主函数随着类的加载就已经存在。
void ：主函数的返回值没null 没有具体返回值。
main：不是关键字，但是一个特殊的词，可以被jvm所识别。
(String[] args) 函数的参数，参数类型是一个数组，该数组中的元素是字符串，JVM在调用主函数时，传入的是new String[0];
4 成员变量和局部变量
(1)作用范围
成员变量作用于整个类中
局部变量作用于函数中，或者语句中。
(2)在内存中的位置：
成员变量：在堆内存中，因为对象的存在才在内存中存在。
局部变量：在栈内存中。
(3)main函数注意点：
在类中写主函数代表该类可独立运行
可在本类中创建本类对象，但一般不这样做。
5 匿名对象
(1)匿名对象是对象的简化形式。
(2)匿名对象调用属性没意义，调用方法有意义，因为方法里有内容。
(3)匿名对象两种使用情况：
<1>当对对象方法仅进行一次调用时。如：new Car().run();
<2>作为实际参数进行传递时。
(4)代码演示：
public static void main(String[] args)
{
show(new Car());
}
public static void show(Car c)
{
c.num = 3;
c.color = "black";
c.run();
}
(5)注意：
<1>当对一个对象进行多个成员调用时，就必须给这个对象起个名字。
<2>匿名对象作参数，show方法执行完，对象就释放内存。
二 封装
1封装概述
(1): 指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
(2)好处：
将变化隔离
便于使用
提高重用性
提高安全性
(3)封装原则 ：
将不需要的对外提供的内容都隐藏起来。
把属性都隐藏，提供公共方法对其访问。
(4) 函数，类，包 和框架 都是封闭体。2 封装private
(1) private关键字
private是一个权限修饰符。用于修饰成员（成员变量和成员函数，内部类) 被私有化的成员只有在本类中有效。
(2)要点说明：
<1>将成员变量私有化， 对外提供对应的set,get方法对其进行访问，提高对数据访问安全性。
<2>将属性私有化以后，类以外即使建立了对象也不能直接访问。
<3>私有仅仅是封装的一种表现形式，权限在访问不到的范围内都是封装。
<4>在访问方式中可加入逻辑判断语句，提高代码健壮性。
三 构造函数
1 特点：
(1) 函数名与类名相同
(2)不用定义返回值类型
(3)不可以写return语句
2 作用：给对象进行初始化
3 注意：
(1)对象一建立就会调用 与之相对应的构造函数。若访问不到相应的构造函数，则对象不能建立。
(2)当一个类中没有定义构造函数时， 系统会默认给该类加入一个空参数的构造函数。
(3)在类中自定义了构造函数后，默认的构造函数就没有了。
(4)多个构造函数是以重载的形式存在的。
4.构造函数与一般函数的区别：
（1）构造函数是在对象一建立就运行，而一般方法是对象调用才运行。
(2) 一个对象建立，构造函数只运行一次，而一般方法可多次被调用。
5 何时定义构造函数？
(1) 当分析事物时， 该事物具备一些特性或行为，那么将这些内容定义在构造函数中。
6.构造代码块。
(1)作用：给对象进行初始化。对象一建立就运行，并且优先于构造函数执行。
(2)和构造函数的区别：
构造代码块是给所有对象进行统一初始化
构造函数是给所对应的对象进行初始化。
(3) 构造代码块中定义的是不同对象共性的初始化内容。
四 this 关键字
1. this关键字
this 是用于区分局部变量和成员变量同名的情况。
this代表它所在函数所属对象的引用。
哪个对象在调用 this所在的函数，this就代表哪个对象。
2.this的应用
(1) 当定义类中的功能时，该函数内部要用到调用 该的对象时， 这时用this来表示这个对象。
(2)但凡本类功能内部使用了本类对象，都使用this来表示。
3 代码示例：
class Person
{
private int age;
Person(int age)
{
this.age = age;
}
public boolean compare(Person p)
{
return this.age == p.age;
}
}
}
3.this在构造函数间的调用
(1)this的调用
<1>this语句： 用于构造函数之间进行互相调用 。
<2>this语句只能定义在构造函数的第一行，因为要初始化要先执行。
(2)this的两种用法：
<1>用于区分同名变量的情况。
<2>用于构造函数间调用 ，一般函数是不能直接调用构造函数的。
(3)代码演示：
class Person
{
private String name;
private int age;
Person()
{
System.out.println("hello");
}
Person(String name)
{
this();
this.name = name;
}
Person(String name,int age)
{
this(name);//构造函数间的相互调用
this.age = age;
}
}}
五 static 关键字
1.用法：
（1）是一个修饰符 ，用于修饰成员(成员变量和成员函数，内部类)
（2） 当成员被静态修饰后，就多了一个调用方式，除了被对象调用外，还可以直接被类名调用，格式：类名.静态成员。
2 static 特点：
(1)随着类的加载而加载。
(2)优先于对象存在。
(3)被所有的对象所共享。
(4)可直接被类名调用 。
3.实例变量和类变更的区别：
(1)存放位置：
类变量随着类的加载而存放于方法区中。
实例变量随着对象的加载而存放于堆内存中。
（2）生命周期：
类变量生命周期长，随着类的消失而消失。
实例变量生命周期随着对象的消失而消失。
4.静态使用注意事项：
静态方法只能访问静态成员。非静态方法即可以访问静态也可以访问非静态。
静态方法只不可以定义this super关键字。因为静态优先于对象，所以静态方法中不可以出现this.
5 静态的利与弊：
(1)利：
节省空间。
可直接被类名调用。
(2)弊：
生命周期过长。
访问出现局限性。（静态虽好，只能访问静态）
6.什么时候使用静态
(1)什么时候定义静态变量（类变量）
当对象中出现共享数据时，该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。
(2)什么时候定义静态函数
当功能内部没有访问到非静态数据（对象的特有数据）,那么该功能就可以定义成静态的。
7.静态代码块：
(1)格式：
static
{
静态代码块中的执行语句;
}
(2)特点：
随着类的加载而执行，只执行一次，并优先于主函数执行，用于给类进行初始化。
六 对象的初始化过程
Person p = new Person("lisi",20);该句话都做了什么？
(1)因为new用到了Person.class,所以会先找到Person.class文件并加载到内存中。
(2)执行该类中的static代码块，如果有的话，给Person.class类进行初始化。
(3)在堆内存中开辟空间，分配内存地址。
(4)在堆内存中建立对象的特有属性，并进行默认初始化。
(5)对属性进行显示初始化。
(6)对对象进行构造代码块初始化。
(7)对对象进行对应的构造函数初始化。
(8)将内存地址赋给栈内存中的引用变量p。
七 制作帮助文档
(1)帮助文档就是类的说明书，可帮助更好地使用类和程序。
(2)制作帮助文档使用的是javadoc.exe工具
F：\haima>javadoc -d myhelp -author -version ArrayTool.java
(3)注：
<1>凡是public修饰的功能都用文档注释来描述，因为都可以被文档注释工具所提取。
<2>只有public和protect修饰的类才可被提取生成文档。
<3>类中默认的构造函数的权限和所属类一致。且默认构造函数的权限是随着
类的变化而变化的。
八 单例设计模式
1.设计模式
(1)设计模式：解决某一类问题最行之有效的方法。java中有23种设计模式。
(2)单例设计模式：解决一个类在内存中只存在一个对象的问题。
2.单例设计的思想与步骤：
(1)将构造函数私有化。
(2)在类中创建一个本类对象。
(3)提供一个方法可以获取到该对象。
3.单例设计模式方式一：饿汉式(开发一般用这个)
代码示例：
class Single
{
private Single(){}
private static final Single s = new Single();
public static Single getInstance(){
return s;
}
}
4:单例设计模式方式二：懒汉式
(1)对象是方法被调用时，才初始化 也叫对象的延迟加载。
Single类进内存，对象还没有存在。只有调用了getInstance方法才建立对象
代码示例：
class Single
{
private staitc Single s = null;
private Single(){}
public static Single getInstance()
{
if(s == nul)
s = new Single();
return s;
}
}
实例的延迟加载，多线程访问时会出现安全问题。使用判断优化如下：
public static Single getInstance()
{
if(s == null)
{
synchronized(Single.class)
{
if(s == null)
s = new Single();
}
}
return s;
}