Java（2012/1/27）

一、流程控制（Java中常用的结构）

        1）顺序结构

        2）分支结构

              ①if条件语句

              ②switch分支语句

        3）循环结构

              ①while循环语句

              ②do-while循环语句

              ③for循环

        4）控制循环结构

              ①break：结束循环

              ②continue：结束本次循环，进入下一次循环

              ③return：结束方法

 

二、有关类的知识

         1）对象是通过引用来操作的，如Person P1 = new Person（）    //用new产生对象，然后用Person类型的变量P1指向所产生的对象。

         2）类是一种引用数据类型，因此a）中定义的Person类型的变量实际上是一个引用，它被存放在栈内存里，它指向实际的Person对象，而真正的Person对象存放在堆内存中。

         3）对于Java中的方法参数传递，无论传递的是原生数据类型还是引用数据类型，统一是传值，原生数据类型传的是数值，引用数据类型传递的是地址。

         4）成员变量和局部变量：成员变量指的是在范围里定义的变量，也就是前面所说的属性；局部变量指的是在一个方法内定义的变量。

 

三、方法重载（Overload）

        1）表示两个或多个方法名字相同，但方法参数不同，方法参数不同有两层含义：

               ①参数个数不同

               ②参数类型不同             //方法的返回值对重载没有任何影响

        2）构造方法重载：只需要看参数即可。如果想在一个构造方法中调用另外一个构造方法，那么可以使用this（）的方式调用，this（）括号中的参数表示目标构造函数的参数。this（）必须要作为构造方法的第一条语句，换句话说，this（）之前不能有任何可执行代码。

        3）Java提供了一个this关键字，this关键字是一个对象的默认引用，this关键字总是指向调用该方法的对象。

 

四、继承（Inheritance）：Java是单继承的，以为这一个类智能从另一个类继承（被继承的类叫做父类（基类，base class），继承的类叫做子类，Java中的继承使用extends关键字）

        1）当生成子类对象时，Java默认首先调用父类的对象的不带参数的构造方法，然后执行该构造方法，生成父类的对象。接下来，再去调用子类的的构造方法，生成子类的对象。（想要生成子类对象，首先需要生成父类的对象，没有父类对象就没有子类对象）

        2） super关键字：super表示对父类对象的引用，如果子类使用super（）显示的调用父类的模狗构造方法，那么在执行的时候就会寻找与super（）所对应的构造方法而不会再去寻找父类的布袋参数的构造方法。与this一样，super也必须要作为构造方法的第一条执行语句，前面不能有其他可执行语句。

        3）关于继承的3点：

              ①父类有的，子类也有

              ②父类没有的，子类可以增加

              ③父类有的，子类可以改变

        4）构造方法不能被继承

 

五、方法重写（Override）：又叫做覆写，子类与父类的方法返回类型一样、方法名称一样，参数一样，这样我们说子类与父类的方法构成了重写关系。

        1）方法重写与方法重载之间的关系：重载发生在同一个类内部的两个或多个方法。重写发生在父类与子类之间

        2）当两个方法形成重写关系是，可以再子类方法中通过super.run()形式调用父类的run()方法，其中super.run()不必放在第一行语句，因为此时父类对象已经构造完毕，先调用父类的run()方法还是先调用子类的run()方法是根据程序的逻辑决定的。

 

        *在定义一个类的时候，如果没有显示指定该类的父类，那么该类就会继承与java.lang.Object类（JDK提供的一个类，Object类是Java中所有类的直接或间接的父类）

 

六、多态（Polymorphism）：所谓多态，就是父类型的引用可以指向子类的对象，或者接口类型的引用可以指向实现该接口的类的实例。

        1）Java引用变量有两个类型：一个是编译时的类型，一个是运行时的类型，编译时的类型由声明该变量时使用的类型据顶，运行时的类型由市级赋给该变量的对象决定。如果编译时类型和运行时类型不一致，就会出现所谓的多态（Polymorphism）。

        2）引用变量在编译阶段只能调用其编译时类型所具有的方法，但运行时则执行它运行时类型所具有的方法。因此，编写Java代码时，引用变量只能调用声明该变量时所有类里包含的方法。例如我们通过Object p = new Person（）代码定义一个变量p，则这个p只能调用Object类的方法，而不能调用Person类里面定义的方法。

        3）与方法不同的是，对象的属性则不具备多态性。

        4）强制类型转换：

               ①向下转型（downcast）：将父类型转换为子类型                   //关于接口与实现接口的类之间的强制类型转换方式与父类和子类之间的强制类型转换方式完全一样

                   父类变量指向哪个之类对象，那么才可以强制转换成这个子类的类型，如

                       Dog extends Animal，Cat extends Animal

                       Animal a = new Dog（）；

                       Dog dog = （Dog）a；

                       Animal b = new Cat（）；

                       Dog d =  （Dog）b；       //是错误的

               ②向上转型(upcast)：把子类型转换为父类型

                  把子类对象赋值给父类变量，这种转型总是可以成功的，如

                       Dog dog = new Dog（）；

                       Animal a = dog；

         5）多态例子：

               ①

                 B extends A，C extends A，D extends A

                 public static void main(String[] args)

                 {

                              A a = null;

                              if(args[0].equals("1"))

                              {

                                         a = new B();

                              }

                              if(args[0].equals("2"))

                              {

                                         a = new C();

                              }

                              if(args[0].equals("3"))

                              {

                                         a = new D();

                              }

                             a.method();

                 }

              ②

                public class PolymorphismTest
               {
                           public void say(Fruit fruit)
                           {
                                       fruit.say();
                           }
                           public static void main(String[] args)
                           {
                                       PolymorphismTest p = new PolymorphismTest();
                                       Apple apple = new Apple();
                                       Pear pear = new Pear();
                                       p.say(apple);
                                       p.say(pear);  
                           }
                }

               class Fruit
               {
                           public void say()
                           {
                                       System.out.println("I'm fruit");
                           }
               }

              class Apple extends Fruit
               {
                           public void say()
                           {
                                       System.out.println("I'm apple");
                           }
               }

              class Pear extends Fruit
              {
                           public void say()
                           {
                                       System.out.println("I'm pear");
                           }
               }