随笔档案

 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);
    }
}

/*
    内部类：
1.在类中定义的类我们称之为内部类,它是外部类的一个成员。
2.内部类可以直接访问外部类的成员,但是外部类不能直接的去调用外部类的成员、
其实内部类调用外部类的成员的时候.其实是使用到了:类名.this.变量名 来访问外部类的成员。
3.在内部类中的方法可以使用this引用调用这个方法的内部类对象.


*/
class Outer
{
    String name = "张三";
    public void run()
    {
        System.out.println("Outer is Running");
    }
    public void show()
    {
        System.out.println("My name is Outer");
        System.out.println(new Inner().age);
    }
    class Inner
    {
            int age = 19;
            public void run()
            {
                System.out.println("Inner is Running");
            }

            public void eat()
            {
                this.run();  //this.代表方法所调用的对象.它的对象是inner 所以输出的是inner
                show();  //因为创建内部类的时候.外部类的对象已经创建了.  如果虚拟机在内部类中找不到.它会到外部类去找这个show()对象.
                System.out.println(Outer.this.name); //其实同等于：Outer.this.name  //类名.name
                System.out.println("Nnner is Eat");
            }
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Outer.Inner  inner = new Outer().new Inner();  //类型要一致!
        inner.run();
        inner.eat();

    }
}

/*
    可以在方法中定义内部类?
    System.out.println(age);为什么会访问不了呢.编译出错/
    其实：当我们在外部类调用A对象的时候.run()方法由于age是存储在栈内存的临时变量中的. 当我们对象调用完毕过后呢.
    有可能是会被释放调的.而当你再次调用的时候 age 的时候呢.由于虚拟机可能会被释放.所以调用不了.
    那么：虚拟机认为你这样做是编译错误的！
*/

class A
{
    String name = "小细"    ;
    public void run()
    {    
        int age = 19;
        class B
        {
            public void run()
            {
                String name = "王五";
                System.out.println("my name is B");
                //System.out.println(age);
                System.out.println(A.this.name);  //通过类名.this.属性名访问外部类的属性.
            }
        }
        new B().run();
    }
}

class Demo 
{
    public static void main(String[] args) 
    {
        A a = new A();
        a.run();
    }
}

/*
    匿名内部类：

*/
class Fruit
{
    public void qupi()
    {

    }
}

class Person
{
    public void eat(Fruit f)
    {
        f.qupi();
        System.out.println("吃完啦！！");
    }
}

class Demo
{
    public static void main(String[] args) 
    {
        Person p = new Person();
        p.eat(new Fruit(){
            public void qupi()
            {
                System.out.println("Apple把皮弄开！");
            }
        }
            );
    }
}

/*
    static修饰的静态内部类:

    1.静态的内部类可以声明非静态的属性和方法.  但是静态的内部类是不能访问外部类非静态的方法.因为外部类的属性需要创建对象才能调用.
    你内部类是不需要创建对象的.所以调用不了。

    2.静态的内部类不能访问非静态的属性.
*/

class Outer
{
    static  String name = "kudy";
    String ID = "888";
    static class Inner
    {
            int age = 19;
            public void run()
            {
                    System.out.println(age);
                    System.out.println("Inner is happy");
                    System.out.println(Outer.name); //因为是不需要创建对象的.所以可以使用Outer.name访问外部的静态的方法。
                //    System.out.println(Outer.ID);
            }
    }
}

class Demo 
{
    public static void main(String[] args) 
    {
        Outer.Inner inner =  new  Outer.Inner();  //静态的内部类一定要静态的去创建！
        //System.out.println(inner.age);
        inner.run();

    }
}
/*
    类的继承
1.使用extends关键字来声明类的关系
2.子类会自动继承父类的属性与方法
*/

class Person
{
    String name ;
    public void run()
    {
        System.out.println("Person is Running");
    }
}

class Man extends Person
{
    public void toLike()
    {
        System.out.println(name +"运动"); //默认会添加上this的
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Man man = new Man();
        man.name = "小细";
        man.run();
        man.toLike();
    }
}
    

/*
    类的继承是为了实现代码的复用性，如果有多个类具有相同的方法.我们应该尽量把她抽出一个类来
*/
class Person
{
    String name ;
    int age;
    public void eat()
    {
        System.out.println(name+"吃饭"+",年龄为："+age);  //this.name this.age
    }
    public void run()
    {
        System.out.println("需要运动");
    }
}

class Student extends Person
{
    public void eat()
    {
        System.out.println("吃一口饭");
        super.eat();  //调用父类的方法、。
        System.out.println("看一下作业");
    }
}
class Teacher extends Person
{
    public void eat()
    {
        System.out.println("抽一根");
        super.eat();
        System.out.println("再来一根");
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Student student = new Student();
        student.name = "小细";
        student.age = 19;
        student.eat();
        student.run();

    }
}
/*
父类型的引用指向子类型的对象.也就是想上类型转换.不需要强制转换
强制转换的要求：  父类型的引用指向子类型的对象。
3.把父类当做子类来使用是不行的,因为子类有的.父类型不一定有
4.当做子类当做父类来用时,只能使用父类型所拥有的方法。
如果调用子类拥有的方法.编译器会报错！所以需要强制转换.但在强制转换的前提下我们要知道父类型的引用是否是指向了子类型的对象
强制转换之前需要判断一下.
注意：
        1.当你父类型的引用指向子类型的对象的时候.你必须要清楚的就是：你访问的属性是会是父类的.而不是子类的.
        因为java在属性方法是做了静态的绑定.谁是我的类型.我就去谁的类型去找.而方法就刚好相反.
        方法就是：谁指向谁.我就调用谁的方法.。  因为是做了动态的绑定。
*/

class Typist
{
    String name = "小细";
    public void type()
    {
        System.out.println("typeing");
    }
}

class Coder extends Typist
{
    String name = "王五";
    public void type()
    {
        System.out.println("tepeing slowly!!!");
    }
    public void code()
    {
        System.out.println("Codeing");
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        //向上类型转换： 父类型的引用指向子类型的对象.
        Typist typist = new Coder();
        //typist.type();  因为你是指向了子类型的引用.所以java做了动态绑定.也就是说你绑定了一个子类型的方法。
        System.out.println(typist.name); 
        /*
            为什么输出小细呢.因为java在检查的时候.属性是不做动态绑定的.也就是说.类型是谁.他就会找类型里面的属性.
        */
        /*
            Code code = new Typist();
            子类型的引用不能指向父类的对象.因为子类有的.父类型不一定有.
        */
        Coder coder;
        if(typist instanceof Coder)  //父类型的引用指向子类型的对象才可以抢走转换！
        {
             coder = (Coder)typist; //强制转换成子类
             System.out.println(coder.name);
        }
    
        

    }
}

/*
    因为java的属性在父类型的引用指向子类型的情况是做了静态的绑定的.所以我们可以这么做！
*/

class Person
{
    private String name = "无名氏";

    public String getName()
    {
        return name;
    }
    public void eat()
    {
        System.out.println("eating");
    }
}
class A extends Person
{
        private String name = "小细";
        public String getName()
        {
            return name;
        }
}
class B extends Person
{
        String name = "kudy";
}
class Demo
{
    public static void main(String[] args) 
    {
        Person p = new A();
        /*
            因为java的父类型的引用指向子类型的对象的时候.方法使用了动态.而属性只使用了静态.也就是说：类型是那个.属性就是从
            那里去找
        */
        System.out.println(p.getName());//这样就是调用了子类型的属性啦~~
    }
}

/*
    什么情况下使用子类当做父类来使用
    匿名内部类：new一个父类对象，后面跟一个花括号，这时不需要创建父类的实例

*/

class Person
{
 String name = "无名氏";
    public void eat()
    {
        //每个人的爱好不同！
    }
}
class    Restaurant
{
    public void run(Person p)
    {
        p.eat();
    }
}


class Chinese extends Person
{

    public void eat()
    {
        String name = "中国人";  //在方法里面是动态调用的哦。
        System.out.println(name+"我是拿筷子吃的！");
    }
}

class American extends Person
{

    public void eat()
    {
        String name = "美国人";
        System.out.println(name+"我只吃汉堡包！");
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Restaurant r = new Restaurant();
        //r.run(new American());
        r.run(new Chinese());

/*
内部类：
        class JB extends Person
        {
            public void eat()
            {
                System.out.println("我是吃垃圾的！");
            }
        }
        r.run(new JB());
*/
    r.run(getIndia());
    }
    static  Person getIndia()
    {
        String name = "印度菜";
        Person p  = new Person(){  //我创建了一个子类.子类里面有eat方法重写啦.之后呢.再把这个重写好的对象返回来.也就是说：父类型的引用指向子类型的对象
        public void eat()
            {
                System.out.println(this.name+"印度菜");
            }
        };
        return p;
    }
}

class A
{
    String name = "小三";
    public String getName()
    {
        return name;
    }
    public void run()
    {
        System.out.println(name);
    }
}

class B extends A
{
    private String name = "小四";
    public String getName()
    {
        return name;
    }
    public void run()
    {
        System.out.println(name);
    }
    public void show()
    {
        System.out.println("我是子类！");
    }
}

class Demo 
{
    public static void main(String[] args) 
    {
        A a = new B();  //父类型的引用指向子类型的对象. 就可以使用子类型与父类型所共同拥有的方法.但是子类出来的就不行。
    //    a.show();
    /*
    System.out.println(a.name);

    如果这样写出来是小三,而不是小四,但是在方法里面输出来的就是小四.因为她的属性在方法里面运行啦.所以是动态的.
    而你单独如果想输出它的属性的话,它是根据了静态绑定来进行操作.也就是输出了类型里面属性的内容!

    那方法就是： 给所有的变量私有化.给他开一个public方法.返回属性！！因为方法是可以转换为动态的.

    有的人可能会问?不相同可以吗? 如果不相同的话.前面已经说过： 就是子类型所特有的.你父类型是不可以调用.除非需要强制转换！
    */
    String name = a.getName(); //这时候方法已经给重写
    System.out.println(name); //输出的会是小四
    }
}

/*
    对象的比较：
        对象的比较不能使用 == 这样比较的是比较地址.  应该用equals方法

        因为所有的类都是默认的继承与Object！  我们可以重写它里面的equals比较方法。
*/

class Person
{
    private String name ;
    private int age ;
    public Person(String name ,int age)
    {
        this.name = name ;
        this.age = age ;
    }
    
    @Override  //告诉编译器我重写父类型的方法！  大写的O
    //重写父类的方法！
    public boolean equals(Object obj)
    {
        if(this == obj)
            return true;
        if(obj instanceof  Person)      //如果你父类型的引用是指向了子类型的对象的.那么就判断.
        {
            //因为是按照了父类型的引用是指向了子类型的对象.首先我们要判断一下.强制类型转换.要不然我们是调用不了子类型的内容
            Person p =(Person)obj;

            if(this.name.equals(p.name)&&this.age == age)
                return true;
        }
        return false;
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
    
        Person p1 = new Person("张三",19);  //p1就是当前对象！
        Person p2 = new Person("张三",19);
        System.out.println(p1.equals(p2));
        


    }
}
class Person
{
    String name ;
    public void eat()
    {
    }
}

class Restaurant
{
    public void show(Person p)
    {
        p.eat();
    }
}
class Chinese extends Person
{
    String name = "中国人";
    public void eat()
    {
        System.out.println(name+"我吃中国菜！");
    }
}

class Test 
{
    public static void main(String[] args) 
    {
        Restaurant r = new Restaurant();
        r.show(new Chinese());

        /*
            匿名内部类的第一种用法！
        */
        r.show(new Person(){
            public void eat()
            {
                System.out.println("日本人吃日本菜！");
            }
        }
        );
        r.show(getUSA());
    }

    public static Person getUSA()
    {
        Person p = new Person(){
            public void eat()
            {
                String name  = "美国人";
                System.out.println(name+"吃美国菜！");
            }
        };
        return p;
    }
}

一、判断题
1、Java语言是不区分大小写的。 错，Java语言是严格区分大小写的
2、Java程序源文件的扩展名为“.jar”。 错，Java程序源文件的扩展名为”.java” 
3、Java程序一般应含有main方法，因为它是所有java程序的入口。正确
4、声明main方法时，其声明可以写成:
Public static void main(String args[])
也可以写成：
Public static void main(String s[])   
 不正确，P不应该大写，应该小写，其他地方是正确的
6、假设有一个名为Hello的java源程序，那么编译这个文件的命令为javac Hello.java。
  正确
7、当运行java程序时，类加载器将字节码加载到内存中，字节码检验器确认所有的字节码是合法的并且不会破坏java的安全限制，然后解释器读取这些字节码并将它们翻译成计算机能够执行的语言。
正确
8、在java语言中，每个ASCII码英文字符占用8个二进制位，而每个中文汉字字符占用16个二进制位。FALSE
正确 英文字符占1个字节8位，中文字符占2个字节16位
9、short s = 64000语句是否正确。
不正确，超出short的取值范围和应该在64000后面加上分号“；”

二、填空题    
1、Sun公司提供了三种java开发工具：其用于工作站和个人计算机的标准开发工具为_
java se _____，用于企业级开发的工具为_java ee______，用于智能移动产品的工具为__ java me______。

2、Java程序中的数据类型分为哪两种_基本数据类型和引用数据类型__________________________。
8种基本数据类型 数值型（byte short int long float double）字符型 char  
布尔型 (Boolean) true 和false
引用数据类型 类，接口，数组
3、配置java开发和运行环境，通常需要配置哪两个环境变量___path_______和________classpath____。

4、在java源文件中，可以有哪几种类型的注释_____单行注释 多行注释和文档注释___________________________。

5、查看当前java虚似机版本的java命令为___java -version________。

6、设一个java源文件的名字为Test.java，则编译该文件的命令为_javac Test.java_____，运行的命令为___java Test___。

7、Java虚似机运行java程序过程为：首先从后缀为_.class____的文件加载代码到内存中，然后在内存中__字节码检验器检查______代码的合法性和安全性，然后___解释器____执行合法和安全的代码。

8、Java语言在____1995______年由____SUN______公司第一次正式发布的，__
詹姆斯•戈斯林（James Gosling）________被誉为java之父。

9、设Hello.java文件的内容如下：
class Hello
{
    static void main(String args[])
    {
        System.out.println(“Hello World!”);
    }
}
下面说法正确的是：D
A、    无法通过编译，因为main方法声明不对。
B、    可以编译，但不可以运行。
C、    可以编译，并可以输出正常结果。
D、    可以编译，但不可以运行，因为文件中没有public类。
  
10、请写出下面程序的运行结果____12_______：
public class Test
{
    public static void main(String args[])
    {
        int i = 0;
        while(true)
        {
            if(i++>10)
            {
                break;
            }
        }
        System.out.printnln(i);
    }
}
X++和++X的区别： X++是X先参与运算再自增，++X是先自增再参与运算
11、请写出下面程序的运行结果____11_______：
public class Test
{
    public static void main(String args[])
    {
        int i = 0;
        while(true)
        {
            if(++i>10)
            {
                break;
            }
        }
        System.out.printnln(i);
    }
}
12、请写出下面程序的运行结果________4________
class Test
{
    public static void main(String args[])
    {
        int a=1,b=2;
        if((a==0)&(++b==6))
            a = 100;
        System.out.println(a+b);
    }
}
（a==0）这个条件为false  （++b==6）这个条件首先b自增1后再参与比较，b变成了3，但这个条件也不成立，所以”a=100;”这个语句没有执行，最后（a+b）的值为（1+3）=4
13、请写出下面程序的运行结果_____4______________。
class Test
{
    public static int method(int x)
    {
        int j = 1;
        switch(x)
        {
            case 1:
                j++;
            case 2:
                j++;
            case 3:
                j++;
            case 4:
                j++;
            case 5:
                j++;
            default:
                j++;
        }
        return j;
    }
    public static void main(String args[])
    {
        System.out.println(method(4));
    }
}

14、请写出下面程序的运行结果_______7____________。
class Test
{
    public static void main(String args[])
    {
        int a = 2;
        switch(a)
        {
            case 1:
                a +=1;
                break;
            case 2:
                a +=2;
            case 3:
                a +=3;
                break;
            case 4:
                a +=4;
                break;
            default:
                a = 0;
        }
        System.out.println(a);
        
    }
}

三、简答题：
1、请判断下面的程序是否能正常编译并运行，如能编译请写出运行结果，如不能请改正。
    int i = 0;
    do
        System.out.println(i++);
    while(i<5);

  正确 ：结果为 0
                1
                2
3
4
2、请指出下面程序可能出现的问题。
    class Test
    {
        public static void main(String args[])
        {
            int i = 0;
            do
{
    System.out.println(i++);
}
        }
    }
没有while 语句，do语句没有中止，不是正确的写法
3、请总结break、continue和return的具体用法，并写出相应的示例程序。
break于中止当前循环中的子语句
continue 语句只能出现在循环语句中，用于跳出循环的剩余语句块，接着执行下一次循环
for(int i=0;i<10;i++)
 {
          if(i%2==0)
        {
               continue; 
        }
      System.out.println(i);
 }
return 用于结束当前执行的语句，并返回一个值
static int getMax(int num1,int num2,int num3)
    {      
         
        int max=num1>num2?num1:num2;
            max=max>num3?max:num3;
        return max ;
    }

四、程序题：
1、    请编写程序，计算1+3+5+……………………+1999的结果。
源程序：//FindSum.java
    public class FindSum
{
    public static void main(String args[])
    {
        int n = 1999 ;
        int sum = findSum(n);
        System.out.println("从0到"+n+"之间的奇数和为：");
        System.out.println("sum="+sum);
    }
    
    static int findSum(int n)
    {
        int sum=0;
        for(int i=0; i<=n; i++)
        {
            if(i%2==1)
                sum+=i;    
        }
        return sum;
    }
}
运行结果:
 
2、    请定义一个整数数组，用一种排序算法对这个数组进行排序。
 源代码：//Demo42.java
public class Demo42
{
    public static void main(String args[])
    {
        int [] num = {12,45,10,23,5,123,89,411,9,78};
        
        System.out.println("排序前：");
        arrList(num);
        
        selectSort(num);
        System.out.println("排序后：");        
        arrList(num);
        
    }
    static void selectSort(int [] arr)
    {
        for(int i=0; i<arr.length-1; i++)
        {
            int pos = i;
            int max = arr[i];
            for(int j=i+1; j<arr.length;j++)
            {
                if(arr[j]>max)
                {
                    max = arr[j];
                    pos = j;
                }
            }
            exchange(arr,i,pos);
        }
            
    }
    static void exchange(int [] arr,int pos1,int pos2)
    {
        int temp;
        temp = arr[pos1];
        arr[pos1] = arr[pos2];
        arr[pos2] = temp;
    }
    static void arrList(int [] arr)
    {
        StringBuffer sb = new StringBuffer();
        for(int i=0; i<arr.length; i++)
            sb.append(arr[i] + ",");
        sb.delete(sb.length()-1,sb.length());
        System.out.println(sb);
            
    }
}
运行结果：
 


3、    请用System.arraycopy实现数组的拷贝。
源代码：//Demo43.java
public class Demo43
{
    public static void main(String args[])
    {
        int [] num1 = {15,89,16,56,10,2,5,123,84,99,753,612};
        int [] num2 = {789,145,100,20,36,95,88,71,40,126,91,65};
        System.out.println("数组拷贝前：");
        arrList(num1);
        arrList(num2);
        
        System.arraycopy(num1,3,num2,3,6);
        System.out.println("数组拷贝后：");
        arrList(num1);
        arrList(num2);        
    }
    
    static void arrList(int [] num)
    {
        StringBuffer sb = new StringBuffer();
        for(int i=0; i<num.length; i++)
        {
            sb.append(num[i]+",");
        }
        sb.delete(sb.length()-1,sb.length());
        System.out.println(sb);
    }
}
运行结果：
 

4、    编写一个程序，程序里定义三个数，并输出这三个数的最大数。
源代码：//Demo44.java
class Demo
{
    public static void main(String args [])
    {
        int num1 = Integer.parseInt(args[0]);
        int num2 = Integer.parseInt(args[1]);
        int num3 = Integer.parseInt(args[2]);
        System.out.println("这三个数的最大值是：");
        System.out.println(getMax(num1,num2,num3));
    }
    static int getMax(int num1,int num2,int num3)
    {      
         
        int max=num1>num2?num1:num2;
            max=max>num3?max:num3;
        return max ;
    }
}

运行结果：
 
5、    编写一个程序，这个程序把一个整数数组中的每个元素用逗号连接成一个字符串，例如，根据内容为[1][2][3]的数组形成内容为“1,2,3”的字符串。 
源代码：//Demo45.java
  class arrDemo
{
    public static void main(String args [] )
    {
        int [] arr = {12,89,45,61,568,945,102,302,44,777,945,689};
        System.out.println("依次输出数组中的元素：");
        arrList(arr);
    }
    static void arrList(int [] arr)
    {
        StringBuffer sb = new StringBuffer();
        for(int i=0; i<arr.length; i++)
            sb.append(arr[i]+",");
        sb.delete(sb.length()-1,sb.length());
        System.out.println(sb);
    }
    
}
运行结果：
 
6、    编写一个程序，从键盘上接受用户输入的需要转的数，得到的一定是字符串，将此字符串转换成十进制整数，然后打印出这个十进制整数对应的二进制形式。
源代码：//Demo46.java
class appDemo
{
    public static void main (String args [])
    {
        int num = Integer.parseInt(args[0]);
        System.out.println("输入的整数为："+num);
        System.out.println("这个十进制的整数对应的二进制形式为：");
        ten2Binary(num);
    }
    static void ten2Binary(int num)
    {
        StringBuffer sb = new StringBuffer();
        while(num>0)
        {
            int temp = num%2;
            num=num/2;
            sb.append(temp);            
        }
        sb.reverse();
        System.out.println(sb);            
    }
}
运行结果：
 

7、     请用移位的方式打印出一个十进制整数的十六进制形式。提示：按每4个二进制位对整数进行移位和去高位处理，得到的结果就是十六进制数的一位，然后按下面三种方式之一（作为作业，要求每种方式都用到）计算出一个十六进制数值对应的十六进制形式： 
1)0-9之间的数值直接加上字符'0'，9以上的数值减去10以后再加上字符'A' 
2)定义一个数组，其中包含0-F这些字符，然后用要计算的数值作为数组的索引号，即可获得其对应的十六进制数据。 
3)Character.forDigit静态方法可以将一个十六进制的数字转变成其对应的字符表示形式，例如，根据数值15返回字符'F'。 
源代码：//Demo47.java
class hDemo
{
    public static void main(String args[])
    {
        int num = Integer.parseInt(args[0]);
        System.out.println("输入的整数为："+num);
        System.out.println("这个十进制整数对应的十六进制形式是：");
        ten2Hex(num);
    }
    static void ten2Hex(int num)
    {
        StringBuffer sb = new StringBuffer();
        char[] buf = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
        for(int i=0; i<8; i++)
        {
            int temp = num&0x000000000f;
            sb.append(buf[temp]);
            num=num>>4;
        }
        sb.reverse();
        System.out.println(sb);        
        
    }
}
运行结果:
 

  1 小算法复习：
  2 /*
  3     不用第三方变量交换两个数的值
  4 
  5     异或：第一个数异或第二个数，之后再把结果异或第二个数。其结果等于它本身！
  6 
  7     1.<<最高位砍掉,最低位补零
  8     （左移多少位，其实就是*2的N次方）
  9     2.>>最低位砍掉.如果最高位是1，前面就是补1,否则补0
 10     //（又移多少位，就是/2的N次方）
 11 */
 12 
 13 class Demo 
 14 {
 15     public static void main(String[] args) 
 16     {
 17         int a = 3;
 18         int b = 5;
 19 
 20         a = a ^ b;
 21         b = a ^ b;
 22         a = a ^ b ;
 23         System.out.println("a == "+a);
 24         System.out.println("b =="+b);
 25 
 26     }
 27 }
 28 /*某个培训中心要为新到的学员安排房间，假设共有x个学员，
 29 每个房间可以住6人，让你用一个公式来计算他们要住的房间数
 30 */
 31 
 32 
 33 class  Demo
 34 {
 35     public static void main(String[] args) 
 36     {
 37         int num = 48;
 38         int homeNuber = getHomeNumber(num);
 39         System.out.println("学生的个数为："+homeNuber);
 40     }
 41     static int getHomeNumber(int num)  //形式参数的初始化其实就是传递进来的参数帮他初始化啦～
 42     {
 43         return (num+5)/6;  //给一个最大的限度！
 44     }
 45 }
 46 
 47 /*
 48     利用无限循环实现0 - 9 之间的数之间的重复循环
 49 */
 50 
 51 class Demo 
 52 {
 53     public static void main(String[] args) 
 54     {
 55         int x = 0;
 56         while(true)
 57         {
 58 
 59             x = (x+1)%10;
 60             System.out.println(x);
 61         }
 62     }
 63 }
 64 
 65 /*
 66     利用小技巧把10进制转换成2进制代码！
 67 */
 68 import java.io.*;
 69 class Demo 
 70 {
 71     public static void main(String[] args) throws Exception
 72     {
 73         //读取键盘
 74         BufferedReader br = 
 75                 new BufferedReader(new InputStreamReader(System.in));
 76         System.out.println("本程序可以帮助您把十进制代码转换成二进制代码：");
 77         String line = br.readLine();
 78         int num = Integer.parseInt(line);
 79         StringBuffer sb = new StringBuffer();
 80         while(num>0)
 81         {
 82             int temp = num % 2; //获取到除以2的余数!
 83             sb.append(temp);
 84             num = num / 2; 
 85         }
 86             sb.reverse();
 87             System.out.println(sb);
 88     }
 89 }
 90 
 91 
 92 /*
 93     十进制转换成十六进制之方法一。
 94 */
 95 import java.io.*;
 96 class  Demo5
 97 {
 98     public static void main(String[] args) throws Exception
 99     {
100         BufferedReader br = 
101                             new BufferedReader(new InputStreamReader(System.in));
102 
103         System.out.println("本程序可以通过十进制转换成十六进制:");
104         
105         String line = br.readLine();
106         int num = Integer.parseInt(line);
107 
108         StringBuffer sb = new StringBuffer();
109         while(num>0)
110         {
111             int temp = num % 16;
112             if(temp>9)
113             {
114                 sb.append((char)(temp-10+'A'));
115             }else
116             {
117                 sb.append(temp);
118             }
119             num = num / 16;
120         }
121         sb.reverse();
122         System.out.println(sb);
123     }
124 }
125 
126 
127 /*
128 用移位的方法来求一个数
129 
130 十进制转换成十六进制
131 */
132 import java.io.*;
133 class Demo 
134 {
135     public static void main(String[] args) throws Exception
136     {
137         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
138         System.out.println("本程序可以帮助您从十进制转换到十六进制：");
139         String line = br.readLine();
140         int num = Integer.parseInt(line);
141         Ten2Hex(num);
142     }
143 
144     static void Ten2Hex(int num)
145     {
146         StringBuffer sb = new StringBuffer();
147         int count = 0x00000000f;
148         for(int i = 0;i<8;i++)
149         {
150             int temp = num & count;  
151             if(temp>9)
152             {
153                 sb.append((char)((temp-10)+'A'));  //类型要注意
154             }
155             else
156             {
157                 sb.append(temp);
158             }
159             num = num >>4;
160             
161         }
162         sb.reverse();
163         System.out.println("结果为："+sb);
164     }
165 }
166 
167 /*
168     打印金字塔程序！
169     求算法的时候要注意：
170     找到求第一个的规律.
171     然后循环就可以。
172 */
173 
174 
175 class Demo 
176 {
177     public static void main(String[] args) 
178     {
179         int n = 4;
180         for(int i = 0;i<n;i++)
181         {
182             for(int j = 0;j<n-i;j++)
183             {
184                     System.out.print(" ");
185             }
186             for(int k =0;k<i*2-1;k++)
187             {
188                     System.out.print("*");
189             }
190             System.out.println();
191         }
192     }
193 }
194 
195 
196 总结：
197     其实switch的参数必须是int类型的,为什么byte char short参数可以传递进来呢？
198 因为它的类型自动提升为int类型啦。也就是隐式的进行了强制转换/所以是可以的.

 1 class Test2
 2 {
 3     public static void main(String[]args)
 4     {
 5         StringBuffer sb = new StringBuffer();
 6         int num = 1234;
 7         while(num>0)
 8         {
 9             int temp = num % 16;
10             if(temp>9)
11             {
12                 sb.append((char)temp-10+'A');
13             }
14             else
15             {
16                 sb.append(temp);
17             }
18             num = num / 16;
19         }
20         System.out.println(sb);
21 
22     }
23 }