final关键字
final修饰的类无法被继承
final修饰的方法无法被覆盖
final修饰的变量只能赋一次值
fianl的引用一旦指向某个对象，则不能重新指向其他对象，但该引用指向对象内部的数据是可以修改的
final修饰的实例变量必须手动初始化，不能采用系统默认值
final修饰的实例变量一般和static联合使用，称为常量
抽象类（半抽象的，可以面向抽象编程，使用多态）
abstract和final关键字不能联合使用(抽象类不能用final修饰)
抽象类中还是有构造方法，因为供子类使用
抽象类中可以没有抽象方法，但抽象方法一定在抽象类中
抽象类也属于引用数据类型
抽象类的子类可以是抽象类也可以是非抽象类
抽象方法只有方法的声明，没有方法体
一个非抽象的类继承抽象类，必须将抽象类中的抽象方法覆盖/重写了，这是java语法上强制规定的，必须的，不然编译器就报错了
面向抽象编程，Animal是抽象的，Animal a=new Dog();
抽象类是无法创建对象的，无法实例化的
接口（完全抽象的，可以面向接口编程，使用多态）
接口是一种引用数据类型，编译之后也是一个class字节码文件
类和类之间是单继承，接口和接口之间是多继承，类和接口之间是多实现
接口中只包含两部分内容，一部分是常量一部分是抽象方法
接口中所有的元素都是public的
接口中的抽象方法定义时，public abstract修饰符可以省略
接口中常量的修饰符public static final可以省略
类和类之间叫做继承(extends)，类和接口之间叫做实现(implements)
非抽象类实现接口时，必须将接口中的抽象方法全部实现，并且重写之后的方法也是public的，不能省略
继承和实现都存在的话，extends关键字在前，implements关键字在后
接口在开发中的作用
(补充：多态在开发中的作用：面向抽象编程，不面向具体编程，降低程序的耦合度，提高程序的扩展力)
总结一句话：面向接口编程，可以降低程序的耦合度，提高程序的扩展力，符合OCP开发原则，接口的使用离不开多态机制（接口+多态才能达到降低耦合度）
类型和类型之间的关系
is a、has a、like a
is a
cat is a Animal（猫是一个/属于一个动物）
凡是能够满足is a的表示"继承关系"
A extends B
has a
I has a Pen（我有一只笔）
凡是能够满足like a关系的表示"关联关系"
关联关系通常以属性的形式存在
A{
B b
}
like a
Cooker like a FoodMenu（厨师像一个菜单一样）
凡是能够满足like a关系的表示"实现关系"
实现关系通常是：类实现接口
A implements B
抽象类和接口有什么区别
抽象类是半抽象的
接口是完全抽象的
抽象类中有构造方法
接口中没有构造方法
接口和接口之间支持多继承
类和类之间只支持单继承
一个类可以同时实现多个接口
一个抽象类只能继承一个类（单继承）
接口中只允许出现常量和抽象方法
package
package是java中的包机制，作用是方便程序的管理，只允许出现在源码的第一行
一般都采用 公司域名倒序+项目名+模块名+功能名（因为公司域名具有全球唯一性）
加上包机制之后，编译 javac java源文件的路径，第一种方法 运行 java 包名.类名(要将字节码放在包目录下)
另一种方法是javac -d . HelloWorld.java
javac 负责编译命令
-d 带包编译
. 代表编译之后生成的东西放在当前目录下
HelloWorld.java 被编译的java文件
以后说类名的时候，如果带着包名描述，表示完整类名(java.util.Scanner)，如果没有带包(Scanner)，表示简类名
import
import语句只能出现在package语句之下，class声明之上
import可以采用星号，表示该包下所有的类 import java.util.*或java.util.Scanner
java.lang.*,这个包下的类不需要使用import导入
访问权限控制符：
public：表示公开的，在任何位置都可以访问
protected：在同一个包中的类或者其他包中的子类可以访问
缺省：同一个包中的类
private：本类中
属性（4个都能用）
方法（4个都能用）
类（public和默认能用，其他不行）
接口（public和默认能用，其他不行）
JDK类库的根类：Object
任何一个类都继承Object，就算没有直接继承，也会间接继承
我们去哪找Object类中的常用方法呢？
第一种：去源代码中（API）
第二种：去查阅java类库的帮助文档（API帮助文档）
常用的方法：
protected Object clone() 负责对象克隆
int hashCode() 获取对象哈希值
boolean equals(Object obj) 判断两个对象是否相等
String toString() 将对象转换成字符串形式
protected void finalize() 垃圾回收器负责调用的方法
toString方法(一般都需要重写，并且输出引用的时候，会自动调用该引用的toString方法)
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
源代码的默认实现：类名@对象的内存地址转换为十六进制的形式
equals方法(一般都需要重写判断两个对象是否相等)
public boolean equals（Object obj）{
return (this==obj)
}
判断两个基本数据类型是否相等直接用==就可以
用==判断对象，判断的是两个对象的内存地址是否相等
所以要判断两个对象的是否相等，老祖宗的equals方法不够用，需要子类重写equals
大结论：Java中比较基本数据类型是否相等用==，Java中所有的引用数据类型统一使用equals方法来判断是否相等
String类其实重写的toString方法和equals方法，不能用==比较两个字符串是否相等。
String aString="123";
String bString="123";
String cString=new String("456");
String dString=new String("456");
System.out.println(aString==bString);
System.out.println(cString==dString);
System.out.println(aString.equals(bString));
System.out.println(cString.equals(dString));
true
false
true
true
eclipse中ctrl+f是在java程序中寻找带有关键字的地方
finalize()方法
源代码 protected void finalize() throws Throwable { }
finalize方法只有一个方法体，里面没有代码
这个方法不需要程序员手动调用，JVM垃圾回收器负责调用这个方法
这个时机称为垃圾销毁时机，如果在垃圾销毁时机想执行一些代码，可以写在该方法中、
hashCode()方法
源代码 public native int hashCode();
这个方法不是抽象方法，带有native关键字，底层调用了C++程序
返回的是一个哈希码，实际上就是一个Java对象的内存地址，经过哈希算法，得出一个值，所以执行结果可以等同看作一个Java对象的内存地址
Object object=new Object();
System.out.println(object.hashCode());
System.out.println(object.toString());
System.out.println(Integer.toHexString(object.hashCode()));
366712642
java.lang.Object@15db9742
15db9742
内部类(使用内部类编写代码，可读性很差，能不用尽量别用)
在一个类的内部定义的类，称为内部类
内部类分为：
public class Test06 {
//静态内部类
static class Inner1 {
}
//实例内部类
class Inner2 {
}
//局部内部类
public void dosome() {
class Inner3 {
}
}
}
实例内部类：类似于实例变量
局部内部类：类似于局部变量(一个方法中的局部内部类，不能被本类的其他方法调用)
匿名内部类：属于局部内部类中的一种，该类没有名字
public class Test07 {
public static void main(String[] args) {
MyMath math=new MyMath();
//math.mySum(new ComputeImpl(),100,200);
math.mySum(new Compute() {//匿名内部类
@Override
public int sum(int a, int b) {
// TODO Auto-generated method stub
return a+b;
}
}, 100, 200);
}
}
interface Compute{
int sum(int a,int b);
}
/*class ComputeImpl implements Compute{
public int sum(int a,int b){
return a+b;
}
}*/
class MyMath{
public void mySum(Compute c,int x,int y){
int retValue=c.sum(x, y);
System.out.println(x+"+"+y+"="+retValue);
}
}
静态内部类：类似于静态变量
内部类的修饰符用四个修饰符中任一都可以
