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();
}
注意: 一定要仔细看注释;