一、关键字instanceof

判断一个对象是不是属于某一个类型，返回值为boolean
1、即子类的对象属于父类的类型，但父类的对象不属于子类的类型。

public class Animal {
private final int AGE;
	public Animal() {
		AGE = 1;
	}
	public void eat() {
		System.out.println("吃肉");
	}

}

class Cat extends Animal {
	@Override
	public void eat() {
		System.out.println("吃鱼");
	}
}

class Dog extends Animal{
@Override
	public void eat() {
		System.out.println("吃骨头");
	}
}

public class Test {

	public static void main(String[] args) {
        Animal a = new Animal();
		// a动物属于猫类型
		boolean b = a instanceof Cat;
		System.out.println("b=" + b);//b=false

		Cat c = new Cat();
		// c猫动物属于动物类型
		boolean b2 = c instanceof Animal;
		System.out.println("b2=" + b2);//b2=true
		}
		}

2、父类的引用可以指向子类的对象，但子类的引用不能指向父类的对象，也不能指向继承为同一个父类的对象

public static void main(String[] args) {
            Animal a = new Cat();//true
             Cat c=new Animal();//false
             Cat c1=new Dog();//false
		}

3、相互指向的对象，也就属于同一个类型。

public static void main(String[] args) {
            Animal a = new Cat();
        boolean b=a instanceof Animal;//true
        boolean b1=a instanceof Cat;//true
		}

4、相互转换的对象，也就属于同一个类型。
注意：要是属于一个类型的才能强转
转换分为：向上转换（又叫泛化）和向下转换

public static void main(String[] args) {
		Cat c = new Cat();
		// 隐式转换，又叫泛化，向上转型
		Animal a = c;
		boolean a1 = c instanceof Cat;
		boolean a2 = c instanceof Animal;
		boolean a3 = a instanceof Cat;
		boolean a4 = a instanceof Animal;
		System.out.println("泛化");
		System.out.println(a1 + " " + a2 + " " + a3 + " " + a4);//true true true true

       //向下转型
		Animal animal = new Animal();
		animal = new Cat();//向下转型需注意的是：首先需要指向该类型，不然会发出异常
		boolean b = animal instanceof Cat;
		System.out.println(b);
		
		System.out.println("向下转型");
		boolean cc = animal instanceof Cat;
		boolean ccc = animal instanceof Animal;
		System.out.println(cc + " " + ccc);
		
	}
	}

5、继承为同一个对象的两个不同的子类，不能相互转换，也不能相互指向 (参考第二条)

二、关键字final

1.final修饰的变量，叫常量
命名习惯，全部大写，单词切换用下划线
常量需要初始化，而且值不可更改
例：final int NUM=4;

2.final修饰的方法不能被override
override作用：否定父类的，使用自己的

3.final修饰的类不能被继承
final修饰的类中的功能，只能自己来用
例如：String

三、static

1、概念：static修饰的属性和方法被该类的所有对象共享（仅此一份）
2、使用：使用类名直接调用
static修饰的代码中不包含this和super
非静态的可以直接调用静态的，反之不行
静态的可以直接调用静态的
3、普通的属性在对象创建才加载内存
静态的属性在类加载就立即加载内存
4、非静态修饰的依赖对象，所以，普通方法看着是对象方法，普通属性属于某个具体对象
static修饰的依赖于类，所以，静态的方法和属性使用类名直接调用

static修饰代码块
类加载的时候，只执行一次
优先级高于代码块
作用：类加载的时候，给类初始化
代码块
每new一次执行一次
作用：给类所有对象初始化
优先级高于构造方法
构造方法
每new一次执行一次
作用：给对象初始化
优先级高于普通方法

例：
class ClassA{ 
static { 
        System.out.println("In ClassA Static"); 
} 
public ClassA(){ 
   		System.out.println("ClassA()"); 
} 
} 

class ClassB{ 
static { 
		System.out.println("In ClassB Static"); 
} 
public ClassB(){ 
		System.out.println("ClassB()"); 
} 
} 

class ClassC extends ClassB{ 
static{ 
		System.out.println("In ClassC Static"); 
} 
public ClassC(){ 
		System.out.println("ClassC()"); 
} 
} 

class MyClass { 
		static ClassA ca = new ClassA(); 
		ClassC cc = new ClassC(); 
static{ 
		System.out.println("In Static MyClass"); 
} 
public MyClass(){ 
		System.out.println("MyClass()"); 
} 
} 

public class TestMain{ 
		public static void main(String args[]){ 
						MyClass mc1 = new MyClass(); 
						MyClass mc2 = new MyClass(); 
						System.out.println(mc1.cc == mc2.cc); 
						System.out.println(mc1.ca == mc2.ca); 
} 
}
结果：In ClassA Static
			ClassA()
			In Static MyClass
			In ClassB Static
			In ClassC Static
			ClassB()
			ClassC()
			MyClass()
			ClassB()
			ClassC()
			MyClass()
			true
			false