随笔 - 19  文章 - 0  trackbacks - 0
<2012年8月>
2930311234
567891011
12131415161718
19202122232425
2627282930311
2345678

常用链接

留言簿

随笔档案

搜索

  •  

最新评论

阅读排行榜

评论排行榜

 1 /*
 2     子类对象的实例化过程
 3     我们可以用一个类的变量记住它的子类的子类的实例.这时如果调用子类中的方法,只需要强制转换子类就可以
 4     没必要非得强制转换子类的子类.
 5     instanceof关键字:也可以判断子类实例也属于父类的类型.
 6 */
 7 
 8 class A
 9 {
10     A()
11     {
12         //如果程序没有写构造方法的/java会默认给它添加构造方法!
13     }
14     public void a()
15     {
16             System.out.println("a() in A");
17     }
18 }
19 
20 class B extends A
21 {
22     B()
23     {
24         super(); //默认调用父类的无参的构造方法!
25     }
26     public void a()
27     {
28             System.out.println("a()in B");
29     }
30 
31     public void b()
32     {
33             System.out.println("b()in B");
34     }
35 
36 }
37 
38 class C extends B
39 {
40     public void a()
41     {
42             System.out.println("a()in C");
43     }
44     public void b()
45     {
46             System.out.println("b()in C");
47     }
48     public void c()
49     {
50             System.out.println("C()int C");
51     }
52 }
53 class Demo 
54 {
55     public static void main(String[] args) 
56     {
57         A a = new C();
58         if(a instanceof C)
59         {
60             C c =(C)a;
61             c.c();
62         }
63         if(a instanceof B)
64         {
65             B b = (B)a;
66             b.b();
67         }
68     }
69 }
/*
    继承的细节
    1.子类不会继承与父类的私有的成员
    2.构造函数是不会被继承.
    3.只支持单继承,可以多重继承.

    ------------------
    1.以后在设计一个类的时候,父类一定要加上一个不带参数的super,否则子类实例化的时候会报错!
    为什么有这样一个机制:
    解答:别人来继承与这样一个类,一定也需要这个子类具有父类的方法.但是别人并不知道在构造函数里面做了一些特别才能实现这个
    的功能.所以java就规定子类实例化的过程中.一定会默认调用与父类的super()的构造方法.如果你在父类中没有定义一个无参的.
    那么在实例化的过程中是会容易出错的.
*/

class Person
{
    private String name ;
    public Person(String name)
    {
        this.name = name;
    }
    public  Person()
    {
            //咱们加一个无参的构造方法!
    }
    public    void eat()
    {
            System.out.println("是人都要吃东西!");
    }

}

class Student extends Person
{    
    public Student()
    {
        //不带参数的构造函数!
        super(); //默认为这个?  但是有这个父类的构造函数吗?显然没有对吧.。
    }
    public void eat()
    {
            System.out.println("抽一根");
            super.eat();
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Student st = new Student();
        st.eat();
    }
}
/*
    子类的实例化过程:子类在创建做了什么事情呢?
    解答:在创建子类的时候,会调用子类的构造函数,在子类构造函数的第一行会默认调用父类的构造函数
                在子类构造函数中如果没有显式地调用父类的构造函数.它会自动的调用父类的无参的构造函数(在这个问题上你要注意)
            我们可以在构造函数中使用this(实参)来调用自己的带参数的构造方法
            还可以用super(实参)去调用父类型的带了参数的构造方法/
            但要注意:this 与super()只能出现一次.  并且在第一行.
            如果一个构造函数调用了this ,那么就不能从第二个语句使用super()
*/


class Person
{
    private String name ;
    public Person()
    {
            System.out.println("无参的Person()被调用啦!");
    }
    public Person(String name )
    {
        this();
        System.out.println("有参的Person()被调用啦!");
        this.name = name;
    }

}

class Student extends Person
{
    private String name;
    public Student()
    {
            super("kudy");
            System.out.println("无参的Student()被调用啦~");
    }
    public Student(String name)
    {
            this();  //与super()不能同时出现
            System.out.println("有参的Student()被调用啦~");
    }

}

class Demo 
{
    public static void main(String[] args) 
    {
        new Student("abc");
    }
}


/*

输出的结构为:
--------------------------------
无参的Person()被调用啦!
有参的Person()被调用啦!
无参的Student()被调用啦~
有参的Student()被调用啦~
*/
/*
    关于多态:
                不变应万变
*/

abstract class Person
{
    public abstract void eat();
}

class Chinese extends Person
{
    public void eat()
    {
            System.out.println("中国的人还是广东人最好啦!");
    }
}
class Shop
{
    public void shopping(Person p )
    {
            System.out.println("咱们去买好东西吃!");
            p.eat();
    }
}
class Demo
{
    public static void main(String[] args) 
    {
        Shop shop = new Shop();
        shop.shopping(new Chinese());

    }
}
/*
    子类实例化的面试题!
    A1 B2 B1
*/

class A
{
    String name = "张三";
    public A()
    {
            System.out.println("A1");  //A1
    }
    public A(String name)
    {
        this();    
        System.out.println("A2");
    }
}

class B extends A
{
    String name = "王五";
    public B()
    { 
            this("张");  //如果有了this 就是默认没了super()
            System.out.println("B1");
    }
    public B(String name)
    {
    //    super();
        System.out.println("B2"); //B2
    }
}

class Demo 
{
    public static void main(String[] args) 
    {
        new B();
    }
}
/*
    覆盖父类的方法:
    子类当中覆盖父类的方法必须要和父类具有相同的方法名,具有相同的参数类型,具有相同的返回值 返回值类型一定要和
    子类的保持一直.这样就是方法的重写
    子类的方法的权限不能比父类有更严格的访问权限,因为我们经常要把子类当做父类来使用.
    子类去访问父类的方法时,会比较一下子类的访问权限.如果权限比父类小.那么就挂啦

    多态: 把子类当做父类来使用,针对父类进行方法的调用.传入不同的子类.执行的结构是一样的.
    除非父类被子类这个哥们重写啦方法~
*/
class Person
{
    public void run()
    {
            System.out.println("run() in Person");
    }
    public Person getInstance()
    {
            return new Person();
    }
}

class Student extends Person
{
    public void run()
    {
            System.out.println("happy");
            super.run(); //调用了父类的run方法!
    }
    public  Student getInstance() //权限不应该比父类的要小.  如果权限要比父类的小.那么就OH.Sorry
    {
        return new Student();
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Student stu = new Student();
        stu.run();
        run(stu);
    }
    //实现了多态!
    public static void run(Person p )
    {
         p = p.getInstance();
        p.run(); //实现了多态
    }
}
/*
final 关键字:最终的!终态的
1.被fina修饰的属性为常量,是不能被更改的.也就是说:值是不能被改变
2.final所修饰的方法不能被重写,也就是说不能被子类所覆盖
3.final修饰所修饰的类是不能被继承的!

一般fina的用法:public static fina String NAME = "kudy"; 
为什么它一般是和static一起的呢?
解答:
既然一个属性都不能被修改啦.是一个常量啦.咱们可以把他定义一个static的.在类出生的时候.它也会跟着出生.
方便.
*/
/*
final class Person
{
    //被final所修饰的类是不能被继承的!
}
*/
class Person
{
    public static final int NUM = 19 ;//给我修饰的常量是不能被修改的!
    public final void show()
    {
            System.out.println("给我修饰的方法都是不能被重写!");
    }
}
class Student extends Person
{
    /*
    public void show()
    {
            System.out.println("真的是不能被重写噢!");
    }
    */
    public void run (int num)
    {
        //先比较后自加!
        System.out.println(++num);
        System.out.println(num++); 
        //? 为多少呢?  20  //因为第一次自加1  后来第二次的时候。先输出值它自己再加1
    }
}
class  Demo
{
    public static void main(String[] args) 
    {
        Student stu = new Student();
        stu.run(stu.NUM);
    }
}
/*
    设计模式!组合
    组合:当一个对象在运作的过程中必须要用到另外一个对象的时候,然而又不是构成继承的关系的!
*/
class Guo
{
    public void heat()
    {
            System.out.println("已经自动的加热啦~");
    }
}
class Chef
{
    //吃食品的时候一定要把它加热嘛~~
    Guo guo;
    Chef(Guo guo)
    {
        this.guo = guo;
    }
    public void cook()
    {
        guo.heat();
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Chef chef = new Chef(new Guo());
        chef.cook();
    }
}
/*
    这样也是一个简单的组合!
*/
class Card
{
    public void spend()
    {
            System.out.println("一不小心就花了600RMB");
    }
}

class Person
{
    Card card ;
    public Person(Card card)
    {
        this.card = card;
    }
}

class Chinese extends Person
{
    public Chinese(Card card)
    {
        super(card);
    }
}

class Shop
{
    public void Shopping(Person p )
    {
        System.out.println("happy完毕!");
        p.card.spend();
    }
}

class  Demo
{
    public static void main(String[] args) 
    {
        Shop shop = new Shop();
        shop.Shopping(new Chinese(new Card()));
    }
}
/*
    抽象类:

1.没有方法体必须要声明为abstract抽象方法
2.含有抽象方法的类一定是抽象类
3.抽象类的定义:用abstract修饰的类叫做抽象类
4.抽象类是不能被实例化的(也就是说不能创建对象!);
5.可以用一个抽象类来继承一个抽象类.会继承所有的方法
6.如果用一个类来继承抽象类,那么必须要实现抽象类里面所有的方法
7.抽象类的访问权限没有什么特殊之处.主要是看修饰符!
8.抽象类里面不一定有抽象方法.但是包含有抽象方法一定是抽象类
*/

abstract class A
{
    abstract void a();//抽象方法!
    public void run()
    {
            System.out.println("A run()");
    }
}

abstract class B extends A
{
    abstract void b();
}

class C extends B
{
    //必须要把它所继承的所有的抽象方法实现!
    public void a()
    {
            System.out.println("A.class");
    }
    public void b()
    {
            System.out.println("B.class"); //实现B
    }
}
class  Demo
{
    public static void main(String[] args) 
    {
        A a = new C();
        if(a instanceof C)
        {
            C c = (C)a;
            c.a();
            c.b();
            c.run();
        }
    }
}
/*
    如果有多个类具有相同的方法声明,但是方法的实现细节不一样.
    我们就需要定义抽象类. 抽象父类

    里面可用到的新学习的知识  : 组合哦
*/

abstract class Person
{
    public abstract void eat();
    public void run()
    {
            System.out.println("吃完饭跑步是最好的!");
    }
}

class Man extends Person
{
    public void eat()
    {
            System.out.println("大口大口的吃!");
    }
}

class WoMan extends Person
{
    public void eat()
    {
            System.out.println("小口小口的吃!");
    }
}

class Begin
{
    private Person p;
    public  Begin(Person p)
    {
        this.p = p;
    }
    public void getBegin()
    {
        p.eat();
        p.run();
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Begin begin = new Begin(new Man());
        begin.getBegin();
    }
}
//甲写的代码

class C
{
    public void run(A a)
    {
        a.c();
    }
}
abstract class A
{
    abstract void a();
    abstract void b();
    abstract void c();  //我这里有一个C是被子类所重写啦!
    abstract void d();
    abstract void e();
    abstract void f();
}

abstract class AbstractB extends A  //需要我都可以实现!但是我用到这种方式!
{
    public void a()
    {

    }
    public void b()
    {

    }
    public void c() //哥们.你也有啊!是不是OH啦
    {

    }
    public void d()
    {

    }
    public void e()
    {

    }
    public void f()
    {

    }
}
class B extends A
{
    public void a()
    {

    }
    public void b()
    {

    }
    public void c() //哥们.你也有啊!是不是OH啦
    {
            System.out.println("c() in B");
    }
    public void d()
    {

    }
    public void e()
    {

    }
    public void f()
    {

    }
}

class  Demo
{
    public static void main(String[] args) 
    {
        /*
        C c = new C();
        c.run(new B());
        */
        C  c = new C();
        //为什么抽象的都可以new呢?但要注意.我这个是匿名内部类
        c.run(new AbstractB(){
            public void c()
            {
                    System.out.println(" AbstractB in C");
            }
        }
            );
    }
}
/*
    模板方法的设计模式:
    定义一个抽象类作为模板,将具体做事情方法定义出来,但是不实现
    2.对外提供一个共有的方法作为接口,规定做事情的顺序/这个方法应该为final 避免了让子类重写
    子类继承模板,实现所有的抽象方法()
*/

abstract class AbatractPrint
{
    abstract void opend();
    abstract void print();
    abstract void close();

    //定义成终态的.避免了子类所修改!
    public final void run()
    {
        this.opend();
        print();
        close();  //调用方法!
    }
}

class StringPrint extends AbatractPrint
{
    private String data;
    StringPrint(String data)
    {
        this.data = data;
    }
    public void opend()
    {
            System.out.print("<<");
    }
    public void print()
    {
            System.out.print(data);
    }
    public void close()
    {
            System.out.print(">>");
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        AbatractPrint abatractPrint = new StringPrint("kudy");
        abatractPrint.run();
        //使用匿名内部类做一下这道题目!
        //我现在不是为了抽象类创建对象.而是为了匿名子类!  //也多多态的一种形式!
        //匿名内部类重写了父类的方法!并且调用一把run();
        new AbatractPrint(){
                public void opend()
        {
                System.out.print("<<");
        }
        public void print()
        {
                System.out.print("show");
        }
        public void close()
        {
                System.out.print(">>");
        }
        }.run();
    }
}
//定义抽象类作为接口,实现个模块之间的解耦
/*
        首先第一种方法的:  显示就是三个人不能同时分工协作啦~~

        咱们传入的时候要注意:  我们传入的是子类.  父类型的引用指向了子类型的对象。
*/
//定义一个抽象的数据产生器!
import java.io.*;
abstract class Generator
{
    abstract String getData();
}

//定义一个抽象的数据处理器
abstract class  DataHandler
{
    abstract String    handleData(Generator generator);
}

//甲负责写数据产生器
class OneGenerator extends Generator
{
    public String getData()
    {
            return "hello";  //产生了一个数据!
    }
}

//乙所负责写的数据处理代码
class OneDataHandler extends DataHandler
{
    public String  handleData(Generator generator)
    {
        String data = generator.getData();
        return  "~~"+data+"~~"; 
    }
}

//数据产生器!
class TwoGenerator extends Generator
{
    public String getData()
    {
        return "小细加油";
    }
}

//数据处理器!
class TwoDataHandler extends DataHandler
{
    public String     handleData(Generator generator)
    {
        String data = generator.getData();
        return "~~~"+data+"~~~";
    }
}


/*
    数据显示!
*/
class Demo 
{
    public static void main(String[] args) throws Exception
    {
        BufferedReader br 
                            = new BufferedReader(new InputStreamReader(System.in));
        /*
        DataHandler data = new OneDataHandler();
        Generator gen = new OneGenerator();
        */
        //通过读取键盘获得用户使用的数据产生器名字
        System.out.println("请输入您使用的数据产生器:");
        String generatorClassName = br.readLine();
        //根据类名反射出类
        //Class class -->new Class()对象 --》class.Class
        //1-1根据类名反射出类!
        Class generatorClazz = Class.forName(generatorClassName);  ////又因为返回的是object 类型/所以我们要强制转换.否则没有办法赋值。
        //根据类创建实例对象(数据产生器)
         Generator  generator=( Generator) generatorClazz.newInstance(); //类创建对象。并且是父类型的引用指向子类型的对象。

         //2.通过反射获得数据的处理器对象
         System.out.println("请输入您要使用的数据处理器:");
         String dataHandlerClassName = br.readLine();
         Class dataHandlerClazz = Class.forName(dataHandlerClassName);
         DataHandler dataHandler = (DataHandler)dataHandlerClazz.newInstance();
        String data = dataHandler.handleData(generator);
        System.out.println(data);
    }
}
posted on 2012-08-07 00:59 、小细 阅读(60) 评论(0)  编辑  收藏

只有注册用户登录后才能发表评论。


网站导航: