1.面向对象时一种思想，将功能封装进对象，强调具备了功能的对象
2.面向对象3大特性： 封装、继承、多态。 找对象，建立对象，使用对象，维护对象之间的关系
3.类和对象的关系： 类就是对现实生活中事物的描述，是对具体的抽象
对象是这类事物实实在在的个体，具体对象是对应java在堆内存中用new建立的实体
属性对应类中的变量，行为对应类中的函数（方法），共同成为类中的成员（成员变量，成员方法）
使用对象的方式：对象.对象成员
Car c = new Car(); c是一个类类型变量，类类型变量指向对象
4.成员变量和局部变量
作用范围不同：成员变量作用于整个类中； 局部变量作用于函数中，或语句中；
内存位置不同：成员变量在堆内存中，因对象存在而存在； 局部变量在栈内存中。
5. 匿名对象： new 类名().方法; 如 new Car.run();
使用方式： 当对对象只使用一次时，可以用匿名对象。 使用完变垃圾
可以将匿名对象作为实际参数进行传递
6.封装 Encapsulation 隐藏对象的属性和实现细节，仅对外提供公共访问方式
好处：将变化隔离 便于使用 提高重用性 提高安全性、
封装原则：将不需要对外提供的内容都隐藏； 将属性封装，对外提供公共方法对其访问；
7. 构造函数
特点：函数名与类名相同 不用定义返回值类型 不可以写return语句
对象一建立，就会调用对应的构造函数。 构造函数用于给对象初始化
当一个类没有定义构造函数时，系统会默认给该类加入一个空参数的构造函数。
当在类中定义了构造函数时，默认的构造函数就没有了。 ； 多个构造函数是以重载的形式存在的
构造函数与一般函数对比： 构造函数在对象一建立就运行，给对象初始化； 一般函数是对象调用才执行，给对象添加功能
一个对象建立，构造函数只运行一次； 一般函数可以被对象调用多次
8：构造代码块 { ................... }
作用：给对象进行初始化 对象一建立就运行，而且优先于构造函数执行
区别：构造代码块是给所有对象进行统一初始化； 构造函数是给对应函数进行初始化
9. this 代表它所在函数所属对象的引用 （哪个对象调用函数，this代表哪个对象）
10. static 是一个修饰符，用于修饰成员变量，成员函数
当成员被静态修饰后，多了一个调用方式，除了被对象调用，还可以被类名直接调用。 类名.静态成员 Person.country
特点：1.随着类的加载而加载 随着类的消失而消失，生命周期长（普通成员变量随对象创建而存在，称为实例变量）
2.优先于对象存在 3.被所有对象共享 4可以被类名所调用
实例变量与类变量区别：
1. 类变量被放在内存的共享区，也称为方法区、数据区； 实例变量随着对象的建立而存在于堆内存中
2.类变量生命周期最长，随着类的消失而消失； 实例变量生命周期随着对象的消失而消失
静态的使用注意事项： 静态方法只能访问静态成员； 静态方法中不可以定义this super 关键字，因为它优先于对象存在； 主函数是静态的
11. 主函数是一个特殊的函数，作为程序的入口，可以被jvm调用
public 代表该函数访问权限最大
static 代表主函数随着的类的加载已经存在
main 不是关键字，是一个特殊的单词，可以被jvm识别
参数 是字符串类型的数组
主函数是固定格式的， 变量名args可以随意写，原名arguments
jvm在调用主函数时，传入的是 new String[0]
12. 什么时候定义静态变量？ 当对象中出现共享数据时
什么时候定义静态方法？ 当功能内部没有访问到非静态数据时
用静态方法组成的工具类， 可以强制让该类不能创建对象， 可以通过将构造函数私有化完成。
13. 帮助文档的制作 javadoc。 java的说明书通过文档注释来完成
/**
这是一个xxx工具类
@author 小米
@version V1
*/
/**
@param abc
@return
*/
写文档的类必须是public 或 protected 修饰的
一个类中的默认构造函数，其权限和所属类是一致的
14. 静态代码块 随着类的加载而执行，只执行一次。 用于给类初始化，优先于其他成分执行
static { ............. ｝
15. 对象的初始化过程：
1. 先找到class文件，加载到内存中
2.先初始类中的static变量，再执行类中的static代码块
3.在堆内存中开辟空间，给对象分配内存地址
4.在堆内存中建立对象的特有属性，并进行默认初始化
5. 对属性进行显示初始化 各种赋值
6.对对象进行构造代码块初始化
7.对对象进行对应的构造函数初始化
8.将对象的内存地址赋给栈内存的变量
//阿里笔试题
public class StaticTest { public static int k=0; public static StaticTest s1=new StaticTest("s1"); public static StaticTest s2=new StaticTest("s2"); public static int i=print("i"); public static int n=99; public int j=print("j"); { print("构造块"); } static { print("静态块"); } public static int print(String s) { System.out.println(++k+":"+s+" i="+i+" n="+n); ++n; return ++i; } public StaticTest(String s) { System.out.println(++k+":"+s+" i="+i+" n="+n); ++i; ++n; } public static void main(String[] args) { new StaticTest("init"); } } 输出结果： 1:j i=0 n=0 2:构造块 i=1 n=1 3:s1 i=2 n=2 4:j i=3 n=3 5:构造块 i=4 n=4 6:s2 i=5 n=5 7:i i=6 n=6 8:静态块 i=7 n=99 9:j i=8 n=100 10:构造块 i=9 n=101 11:init i=10 n=102
16. 设计模式 一共有23种 解决某一类问题最行之有效的方法
单例设计模式：解决一共类在内存中只存在一共对象
懒汉式: 方法被调用时，对象才初始化。 Single 类进内存，对象还没存在，只有调用了get方法时，才建立对象
饿汉式：Single类一进内存，就已经创建好了对象
class Single //饿汉式 { private Single(){} private static Single s = new Single(); public static Single getInstance() { return s; } }
class Single //懒汉式 { private Single(){} private static Single s = null; public static Single getInstance() { if(s==null) s = new Single(); return s; } }
17. 继承： 提高了代码的复用性
让类与类之间产生了关系，从而有了多态的特性
类与类之间有所属关系时，才可以继承。
java只支持单继承，多继承容易带来安全隐患，当多个父类中定义了相同功能，功能内容不同时，子类对象不确定运行哪一个
java保留了这种机制，并用另一种体现形式来表示，叫多实现。
java支持多层继承。
18.子父类出现后，类成员的特点
1.变量 如果子类中出现了非私有的同名成员变量，子类要访问本来中的变量，有this; 访问父类中的变量，用 super。 this代表本来对象的引用， super代表父类对象的引用
2.函数 当子类出现和父类一模一样的函数时，子类对象调用该函数，会运行子类的函数，父类的函数会被覆盖（重写）
覆盖的特点： 子类覆盖父类，必须保证子类的成员权限大于对应的父类权限，否则编译失败 ； 静态只能覆盖静态
重载只看同名函数的参数列表，重写：子父类函数要完全一样
19.子父类中构造函数的特点：
子类的实例化过程
子类的所有的构造函数，默认都会访问父类中空参数的构造函数。
因为子类每一个构造函数的第一行都有一句隐式的super(); 当父类中没有空参数构造函数时，子类必须手动通过super形式指定要访问父类中的构造函数
子类的构造函数第一行也可以指定this语句访问本类中的构造函数，子类中只有会有一个构造函数访问父类中的构造函数
20.final 关键字
1.可以修饰类 、 函数 、 变量
2.被final修饰的类不可以被继承。 继承有个弊端：破坏了封装性
3.被final修饰的方法不可以被重写
4.被final修饰的变量是一个常量，只能赋值一次。既可以修饰成员变量，又可以修饰局部变量
应用：描述事物时，一些数据的值是固定的，为了增强阅读性，给这些值起名，用final修饰。作为常量，书写规范所有字母大写，单词间下划线连接
public static final double PI = 3.14;
5.内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量
21.抽象类的特点：
1.抽象方法一定在抽象类中 2.抽象方法和抽象类都必须被abstract修饰 3.抽象类不可以用new创建对象
4.抽象类中的方法要被使用，必须由子类复写其所有的抽象方法后建立子类对象使用。如果子类只重写了部分抽象方法，那么该子类还是抽象类
abstract int power();
抽象类不可以实例化。
抽象类中可以不定义抽象方法，作用是不让建立对象
22. 模板方法： 在定义功能时，功能的一部分时确定的，但有一部分是不确定的，确定的部分在使用不确定的部分，那么这时就就将不确定的部分暴露出去，
由该类的子类完成。
23. 接口 interface 是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以通过接口的形式表示
接口中成员修饰符是固定的
成员常量： public static final
成员方法： public abstract
接口不可以创建对象，需要被子类实现。子类对接口中的抽象方法全部覆盖之后，才可以实例化。 implements
接口可以被类多实现， java中一个类只能继承一个类，但可以同时实现多个接口
接口与接口之间可以有继承关系
24. 多态： 某一类事物的多种存在形态
多态的体现：父类的引用指向了自己的子类对象 ； 父类的引用接受自己的子类对象（形参）
多态的好处： 大大提高了程序的扩展性
多态的前提：必须是类与类之间有关系：继承、或实现 ； 存在覆盖
多态的弊端： 提高了扩展性，但是只能使用父类的引用访问父类中的成员
当父类引用指向了自己的子类对象，可以强制将该引用转换成子类类型。
关键字 instanceof ： 对象名 instanceof 类名 用于判断该对象是否属于该类
多态中成员函数的特点：
在编译时期：参阅引用型变量所属类中是否有调用的方法。如果有，编译通过
在运行时期：参阅对象所属的类中是否有调用的方法。
**多态中成员变量、静态成员函数的特点： 无论编译运行，都会指向 引用型变量所属的类
class Fu { public static void say() { System.out.println("父类"); } } class Zi extends Fu { public static void say() { System.out.println("子类"); } } class Demo { public static void main(String[] args) { Fu f = new Zi(); f.say(); } } //结果是打印 父类
25. object 类 是类层次结构的根类。该类中定义的方法是所有对象都具备的功能。
public boolean equals(object obj) 判断2个对象是否相等
public boolean equals(object obj) { if(!(obj instanceof Demo)) return false; Demo d = (Demo) obj; return this.num == d.num; }
pubic String toString()