---恢复内容开始---
1、面向对象
三大特性：封装、继承、多态
面向过程-想到啥做啥
面向对象-整体化分析，再分块制作。
发生变化时，面向过程可能要推倒重做，面向对象则可以适应变化
1.1封装：Encapsulation
(1)把对象的属性和行为看成一个密不可分的整体，将这两者“封装”在一个不可分割的独立单位（对象）中。
(2)把不需要让外界知道的信息隐藏起来，有些对象的属性及行为允许外界用户知道或使用，但不允许更改，而另一些属性或行为，则不允许外界知道，或只允许使用对象的功能，而尽可能隐蔽对象的功能实现细节。
另一个特点，为封装在一个整体内的变量及方法规定不同级别的“可见性”或访问权限
1.2继承：
(1)提高代码复用性，提高开发效率。
(2)首先拥有反映事物一般特性的类，然后再其基础上派生出反映特殊事物的类。
(3)若子类只允许继承一个父类，则称为单继承；若允许继承多个父类，则称为多继承。java通过接口(interface)的方式来弥补因java不支持多继承而带来的子类不能想用多个父类的成员的缺点。
1.3多态性：
允许程序中出现重名现象。使程序的抽象程度和简洁程度更高，有助于程序设计人员对程序的分组协同开发。
(1)方法重载
(2)对象多态，子类对象与父类对象进行相互转换，而且根据其使用的子类的不同，完成的功能也不同。
PS:面试关于对象
面试官需要寻找具有专业编程功能的人来完成公司工作
我就是那个对象，具备这个功能
你就是在指挥我，就是在使用我的专业技能
当然，我不禁具备专业编程技能，还会一些更多的。
一切皆对象，万物皆对象。
2、多个引用指向同一个对象，一变全变。
3、成员变量和局部变量
成员变量作用于整个类，
局部变量作用于函数中，或语句中。
成员变量在堆内存中，因对象存在而存在
局部变量，栈内存
4、匿名对象
new Car().num=5;//执行完变垃圾
new Car().color="blue";//执行完变垃圾
new Car().run;
使用方式
(1)当对对象的方法只调用一次时可用，较简化。
若对一个对象进行多个成员调用，必须给对象起名字
(2)可将匿名对象作为实际参数进行传递
且调用过后，会自动变为垃圾，释放内存
5、封装
5.1、私有private(仅是封装的一种形式)
权限修饰符，用于修饰类中的成员（成员变量，成员函数）
私有只在本类中有效
可提供方法来访问，在方法中加判断等语句。
提高代码的健壮性
6、构造函数
作用：对象的初始化(没写的话都自带空参数的构造函数)
多个构造函数是以重载的形式存在
6.1、构造函数与一般函数比较
构造函数在对象已建立就运行，给对象初始化。 只运行一次
一般函数是对象调用才执行，给对象添加其具备的功能。 可调用多次
7、构造代码块
{}//没函数名
作用: 给对象初始化
对象一建立就运行，优先于构造函数。
区别: 构造代码块是对所有对象进行统一初始化，
而构造函数是给对应的对象初始化。
8、this关键字
8.1、哪个对象调用this所在的函数，this代表哪个对象
定义类功能时，该函数内部要用到该函数的对象时，这时用this来表示这个对象
1 package learn;
2
3 class Person{
4 private String name;
5 private int age;
6 Person(int age)
7 {
8 this.age=age;
9 }
10 public void speak(){
11 System.out.println("name="+name+"...age="+age);
12 }
13 public boolean compare(Person p)
14 {
15 return this.age==p.age;//相当于p1.age==p2.age;
16 }
17 }
18
19 public class PersonDemo3 {
20 public static void main(String[] args){
21 Person p=new Person(40);
22 Person p2=new Person(20);
23 System.out.print(p.compare(p2));
24 }
25
26 }
8.2、构造函数之间调用，可用this
不过this()语句需要放在第一行。即初始化动作需要第一行执行，有更细致的初始化则使用更细致的。
9、静态static
修饰符，用于修饰成员(成员变量，成员函数)，共性变量,存放于方法区
调用方式+1: 类名.静态变量
9.1特点
(1)随着类的加载而加载，随着类的消失而消失即生命周期长(弊端1)
(2)优先于对象存在
(3)被所有对象共享(利处2)
(4)可以直接被类名调用（利处3）
9.2、类变量和实例变量
类变量随着类的加载而存在于方法区中(利处1)
实例变量随着对象的建立而存在于堆内存中
9.3、静态方法
静态方法只能访问静态成员，不可用this,super关键字。(弊端2)
ps:相当于有了类名.
9.4、main函数
main不是关键字，只是可被jvm识别的特殊单词
public static void main(String[] args)唯一可改args
传入的是new String[0]
1 package learn;
2
3 public class MainDemo {
4 public static void main(String[] args)
5 {
6 String[] arr={"hah","hehe","heihei","xixi","hiahia"};
7 MainTest.main(arr);
8 }
9 }
10 class MainTest{
11 public static void main(String[] args)
12 {
13 for(int x=0;x<args.length;x++)
14 {
15 System.out.println(args[x]);
16 }
17 }
18 }
9.5何时使用静态
共享数据--静态变量
功能内部没有访问到非静态数据--静态方法
工具类私有化，包括构造函数都私有化，只通过类名调用。
10、调用他人的class时，记得设置classpath=.;c\class;（记得保留当前路径）
11、文档
必须为public类
javadoc -d myhelp -author -version ArrayTool.java
生成处的文档名 作者，版本号可不加 文档依据的源文件
index文件开始查看
12、静态代码块
随着类的加载而执行，只执行一次，用于给类初始化，无法含有非静态内容,优先于主函数
1 package learn;//执行结果 ac9d
2
3 class StaticCode{
4 int num=9;
5 StaticCode()
6 {
7 System.out.println("b");
8 }
9
10 static{
11 System.out.println("a");
12 }
13
14 {
15 System.out.println("c"+num);
16 }
17
18 StaticCode(int x)
19 {
20 System.out.println("d");
21 }
22
23 public static void show(){
24 System.out.println("show run");
25 }
26 }
27
28 public class StaticCodeDemo{
29 public static void main(String[] args){
30 new StaticCode(4);
31 }
32 }
13、执行顺序
1、因new用到了Person.class，所以会先找到Person.class文件并加载到内存中。
2、执行该类中的static代码块
3、在堆内存中开辟空间，分配内存地址。
4、在堆内存中建立对象的特有属性，并进行默认初始化。
5、对属性进行显式初始化
6、对对象进行构造代码块初始化
7、对对象对应的构造函数初始化
8、将内存地址赋给栈内存的p变量。
14、单例模式-一个类中只存在一个对象
14.1特点
(1)禁止其他程序建立该类对象--将构造函数私有化
(2)让其他程序能访问该类对象--类中创建一个本类对象
(3)方便其他程序对对象的访问--可以对外提供一些访问方式（只有这个进出口）
保证对象在内存中唯一才用到
饿汉式:
Single类一进内存就已经创建好了对象
1 package learn;
2
3 class Single{
4 private int num;
5 public void setNum(int num)
6 {
7 this.num=num;
8 }
9 public int getNum()
10 {
11 return num;
12 }
13 private Single(){}
14 private static Single s=new Single();
15 public static Single getInstance(){
16 return s;
17 }
18 }
19 public class SingleDemo {
20 public static void main(String[] args)
21 {
22 Single s1=Single.getInstance();
23 Single s2=Single.getInstance();
24 s1.setNum(40);
25 System.out.print(s2.getNum());
26 }
27 }
懒汉式:
Single类进内存，对象还不存在，只在调用了getInstance方法时，才建立对象.
1 package learn;
2 class Single2{
3 private static Single2 s=null;
4 private Single2(){};
5 public static Single2 getInstance(){
6 if(s==null)//此处两条语句执行，容易因cpu多线程导致报错。具体解决见多线程。故除面试外，多用饿汉式
7 s=new Single2();
8 return s;
9 }
10 }
11 public class SingleDemo2 {
12 public static void main(String[] args){
13 Single2 s2=Single2.getInstance();
14 }
15 }