1.多态的内存分析：
上图中My是Http的子类；Http是Objedt的子类；当生成一个My对象调用他的service()的时，而他自己没有重写这个方法所以就调用Http的service（他中调用了doGet（）问这个doGet（）；是谁的doGet（））；然后在调this的doGet（）；记住一句话就是途中的this都是指当前对象也就是My类创建的对象，所以调用的是子类的doget（）；
类似的代码如下：
package Class.StudeyInDepth;
public class myServelet {
public void service() {
System.out.println("I am serivce");
doit();//这句话写完整应该是this.doit();而这个this表示的是当前对象当子类对象的调用的时候那么this指的就是子类
}
public void doit() {
System.out.println("Do it");
}
}
package Class.StudeyInDepth;
public class Servelet1 extends myServelet {
public void doit() {
System.out.println("我是子类的doit");
}
}
package Class.StudeyInDepth;
public class Test {
public static void main(String[] args) {
Servelet1 a = new Servelet1();
a.service();
}
}
注意：经上面的分析我们可以想到输出的是
2.抽象类；abstract
只要包含了抽象方法的类，都是抽象类，所以它可以有属性和非抽象方法；
抽象方法：就是只有声明，没有方法体；
子类继承抽象类必须重写抽象类的抽象方法。（这样不就是提供了一个模板（标准））。
抽象类不能实例化对象，他只能同于被继承；
java的抽象类中不能有主函数；
package abstractClass;
/**
* 测试抽象类
* @author Wang
*
*/
public abstract class Animal {
String name;//可以有普通的属性
public abstract void run() ;
public void cry() {//可以有普通的方法
run();//这里是可以调用这个方法的，这里的this必定是子类的this因为他是个抽象类是没办法实例化对象的
}
}
class Tigger extends Animal {
public void run() {
System.out.println("飞奔!!");//这个必须重写父类的抽象方法；
}
}
package abstractClass;
public class testAbstract {
public static void main(String[] args) {
Animal a = new Tigger();
a.run();
Tigger b = new Tigger();
b.cry();
}
}
3.接口的详解：（interface）和接口的实现（implement）
接口中只有常量，抽象方法；
接口的作用就是设计与实现的分离；利于分工；他是最抽象的；
接口是可以是多继承的
类要实现接口
package testInterface;
public class Test implements MyInterface,Attack{//实现接口,可以实现多个接口
@Override//这个是注解 有这个的话下面就必须是重写
public void test01() {
System.out.println("重写了test01");
}
@Override
public int test02() {
System.out.println("重写了test02");
return 0;
}
public static void main(String[] args) {
Test a = new Test();
a.test01();
}
@Override
public void attack() {
System.out.println("fight");
}
}
package testInterface;
public interface MyInterface {
//接口里面只有常量和抽象方法
String MAX_GREAD = "BOSS";//默认是 有 public static final
int MAX_SPEED = 140;
public void test01();//这里必须是公开的 而且默认是public abstract
public int test02();
}
interface Attack {
void attack();
}
interface Output{
void output();
}
interface Output1{
void output1();
}
interface Output2 extends Output,Output1{//接口是可以多继承
void output2();
}
package testInterface;
public class testOutput implements Output2 {
@Override
public void output() {//看实现Output2需要重写3个因为Output2继承了两个接口；
// TODO Auto-generated method stub
}
@Override
public void output1() {
// TODO Auto-generated method stub
}
@Override
public void output2() {
// TODO Auto-generated method stub
}
}
4.回掉（CallBack也叫Hook 也叫模板方法模式)；
package TestCallback;
/**
* 这个Java文件中的结论实在一个包的前提下
* @author Wang
*
*/
public class printFrame {
public static void drawFrame(MyFrame f){//这里传不同的子类下面就调用不同的paint（）； //如果是接口的话这里的参数改成IMyFrame f就可以了
System.out.println("启动线程");
System.out.println("增加循环");
System.out.println("查看消息栈");
f.paint();//这里就是一个Callback（）的函数[就是不知道该怎么写paint 可以来调用不同子类不同的paint]，说白了就是实现多态
System.out.println("启动缓存，增加效率");
}
public void aaa(){
System.out.println("可以调用aaa");
}
public static void bbb() {
System.out.println("静态的我bbb");
}
public static void main(String[] args) {//在跟文件名相同的这个类中要
//aaa();//不创建对象编译这样写是通不过的
bbb();//这样写是可以被调用的 （目前static修饰的方法就知道这一个作用 还有就是不能访问普通属性）
printFrame a = new printFrame();//跟Java文件名字相同的这个类是可以在别的Java文件中创建对象的 也可以在自己的文件中是可以创建
a.aaa();//不加static的方法要有对象
System.out.println("****************");
drawFrame(new GameFrame01());
System.out.println("****************");
drawFrame(new GameFrame02());
System.out.println("****************");
drawFrame(new MyFrame());
}
}
class GameFrame01 extends MyFrame{//回调的必须继承，保证自己可以传过去；//这里跟普通多态的区别就是里面还有一些是父类的东西 //接口的话就是implement
public void paint() {
System.out.println("这里调用的是GameFrame01的paint");
}
}
class GameFrame02 extends MyFrame{
public void paint() {
System.out.println("这里调用的是GameFrame02的paint");
}
}
class GameFrame03 extends MyFrame{
public void paint() {
System.out.println("这里调用的是GameFrame03的paint");
}
}
//public class TestPublicClass{} 每个java文件中只能有一个public修饰的类
class test01{//跟Java文件明不相同的类是可以在别的java文件中创建对象的；
String name;
public static void main(String[] args) {//一个java函数是可以有两个main函数的但是这个main（）函数里面的东西并没有执行
printFrame b = new printFrame();
System.out.println("可以有两个main函数吗");
b.bbb();
}
}
package TestCallback;
/**
* 这个Java的结论实在同一个包的前提下
* @author Wang
*
*/
public class MyFrame extends printFrame{
public void paint() {//callback的这个方法可以写成 abstract //或是写成接口（那么类就是implement这个接口） //那么这个方法就必须重写了
System.out.println("把自己的窗口画出来");
}
public void testStaticMenthod() {
aaa();
bbb();
}
test01 c = new test01();//跟Java文件明不相同的类是可以在别的java文件中创建对象的；
printFrame b = new printFrame();//跟Java文件名字相同的这个类是也能在别的Java文件中创建对象的
}
interface IMyFrame{//一般情况下写接口的时侯都喜欢首字母都喜欢是大写的I
void paint();
}
注意： 一定要仔细看注释；