JAVA基础综合

注：因内容有限制不能全部显示，请下载附件里面的内容查看更多

1、JAVA CLASSPATH
    CLASSPATH一般设置为.;%JAVA_HOME%\lib;这样JAVA解释器首先在当前目录寻找类，如果未找到则到lib目录寻找。
    这样如果当前目录
    如果类如Good.java在E:下，这里在CMD中切换到E：编译及解释都通过，但切换到D：则会提示找不到类Good.这时可在CMD中输入命令SET CLASSPATH=E:
    这样JAVA解释器执行时会从CLASSPATH所定的目录开始寻找，这时会发现即使命令提示符在D：输入JAVA Good仍可执行。
    按此思路如果此时我输入命令：SET CLASSPATH=D:\,而Good.java文件仍在E：根目录下，此时我在CMD中切换到E：，执行JAVA Good会发现找不到类Good.
    这还是因为寻找的路径是按SET CLASSPATH来的，所以在这里你会发现虽然明明E：下有这个文件，但切换到这个目录反而执行不了。。
    要想解决这个问题，需要修改CLASSPATH，如SET CLASSPATH=D:\;.;这样如果在D下面寻找不到所需的类，会再到当前目录寻找。这里要注意的是这个"当前"是指的CMD中你所切换的目录，如果此时不在E：而在F：下执行命令，也会提示找不到类的。
    
2、JAVA数据类型
    JAVA数据类型分数值数据类型和布尔数据类型(boolean),数值数据类型分字符类型char，整型(short,int,long),实型(float,double)型。
    boolean和byte为1个字节,char,short为两个字节，int,float为四个字节，long,double为八个字节。
   
            关于基本数据类型运算时转换时的几点说明：
                1、运算时总是将小的类型转换为运算式中最大的类型再进行运算；
                2、byte,char,short不会互相转换，它们会先转换成int类型再运算；
                3、整型默认为int类型，实型默认为double类型。这条很重要，很多下面的问题都可从这里得到解释。如
               
                        (1) 注意:byte类型参与运算的时候会自动转为int型。。
                        byte b=2;      //特殊点：JAVA中允许将int类型直接声明给byte,char,short类型，即byte b=2; 中2为int类型;char c=12;但要注意不能超过它们各自的范围。如byte最大为128则不能byte b=129;
                        b=b*3;                //这里运算时，将b看作int类型，3为int类型。所以要转换。
                        这里应使用强制类型转换：b=(byte)(b*3);
                        但是注意了：
                        long L1=123;      //没错
                        long L1=L1+23;   //没错
                        (2) 实型：
                        float f=3.2;
                        这个定义编译时会出错。原因是系统会将3.2当作double型来看，所以这里改为：
                        float f=3.2f;
                        (3)注意各类型变量的默认值，boolean型默认为true，值只有true和false.
    (4)数组：不能象c语言一样定义：int a[3];
        JAVA中定义数组应为：int[] a = new int[3];
    也要注意：int[] num={1,2,3};这是对的，但下面却会提示错误。
        int[] num1;
        num1={1,2,3,4};//error
    还要注意：int[] num1=new int[]{1,2,3};//right
        int[] num2=new int[3]{1,2,3};//error,如果在后面已列出值就不要再加3这一数据元素个数了。
    另一种数组的定义和赋值方式：
        int[] num=new int[3];
        num[0]=2;num[1]=4;num[2]=322;
    (5)字符的赋值：可以给字符赋整数如：char c=97;

3、for语句
    for(int i=0;i<10;i++)
        {
            System.out.println("sf");
        }
        System.out.println(i);//error*/
    要注意，java是for语句中定义的i，只在for语句范围内有效。

4、位运算
    位运算有&(按位与)、|(按位或)、^(按位异或)、~取反，<<左移运算符，>>右移运算符。
    按位与:
        一般用于清零，即找一个与其相反的数相与结果为0.如：00101011与10010100按位与结果为00000000
        按位与另一用途为保留整数的高位或低位字节.如将:00101100 10101100与0000000011111111或1111111100000000相按位与操作结果使其只保留低位字节和高位字节.
    按位或:
        常用于将低八位或高八位全置为1.如a:00101100 10101100 与o(0377)即二进制的00000000 11111111相或,置低八位为1.
    按位异或:
        按位异或,即同则0异则1.如a:00111001^00101100=00010101
        常用于使特定位翻转,即想使哪几位由1变为0,只需将其与1异或即可.
        与0相异或,保留原值.
        异或还用做交换两个值,不用临时变量...                 
            fn(int x,int y)
            {
                x=x+y;
                y=x-y;
                x=x-y;
            }
        如a=3,b=4想将a,b的值互换只需:a=a^b,b=b^a,a=a^b;
            如:   a=011
               (^)b=100
            _____________
              a=a^b=111=7  (异或之后:a=7)
                (^)b=100
            _____________
              b=b^a=011=3  (异或之后:b=3)
                              a=111=7
                        ______________
                          a=a^b=100=4  (异或之后:a=4)
            最终完成了a与b的互换.这可用于排序中交换值,而不用声明temp变量.
        推导:b=b^a,而a=a^b,有b=b^(a^b)=a^b^b,b^b=0,所以:b=a^0,而上面说过与0异或保留值.故b=a;
             a=a^b,而a=a^b,b=b^a=b^(a^b),所以,a=a^b^(b^(a^b))=a^a^b^b^b=b;即a=b;
    按位取反：各位均取反。
    左移运算符：二进制位整体向左移，右补0,如：3＝00000011，向左移两位，右补0得：00001100＝12,由此可知，左移相当于乘2,左移两位3*4＝12；
        左移运算比乘法快很多，有些C编译程序自动将乘2的运算用左移一位来实现，将乘2（n）的幂运算处理为左移n位。
        但要注意的是：如c语言中unsign int 为2字节，取值范围为0－255,所以64（01000000）左移一位时溢出为0，乘2,128,如果再左移一位，则溢出1,得到结果为0.
    右移运算符：右移n位相当于除以2的n次方。
        右移需要注意符号位的问题，如果符号位为0,即为正，则移入0.如果符号位为1即负数，则右移之后，左边是补0还是补1取决于所用的计算机系统。
        左边补0的称为逻辑右移，即简单右移；
        左边补1的称为算术右移。
    上述为c语言中的右移表述，
        在java及javascript语法中
        注意>>(Signed right shift)表示带符号右移，即右移后左补1；
        >>>(Unsigned right shift)表示无符号右移，即右移后左补0；
    如： a            x                 x<<2              x>>2                  x>>>2
         17       00010001           00|01000100        00000100|01            00000100|01
        -17       11101111 (补码)    11|10111100        11111011|11(补码)      00111011|11
        如：a(113755)   1001011111101101  a>>1:0100101111110110(逻辑左移),a>>1:1100101111110110(算术右移)
    用操作系统上的计算机由10进制到二进制的转换得到的就是补码值.

5、求一负数的补码。(正数的补码与原码是一样的,所以如果给出补码符号位为0则表示正数,补码即原码)
    如题：(1)将其转换成十进制数，取它的绝对值(2)将它的绝对值的二进制行式取反(3)取反后加1、
        如－6.求6的二进制为：00000110,取反得：11111001,加1：11111010,－6的补码即为：11111010.
        上面方法也可以理解为：负数的符号位不变，其它各位取反再加1.即－6：10000110, 取反：11111001,加1：11111010.

6、已知一个负数的补码，求这个负数的值的步骤。
    如题：(1)将各位取反。(2)将其转换成十进制数(3)加上负号再减1.
        如：x的补码为：11111010,求x=?  采用以上方法得：取反：00000101,得5,加上负号再减1,－5－1＝－6.
            x=-6.
        如上面例4中－17经过右移后得：11111011求这个值。取反：00000100,十进制4,加负号再减1得－5.
          (2)也可以先依靠补码求出原码,再求值.方法就是对该补码再求补码
            如:x的补码为：11111010,求x的原码.由于最高位为1即负数,所以符号位不变其余各位取反得10000101,再加1得10000110即-6

7、在JAVA中BIN目录中JAVAP为反编译工具，通过JAVAP Student可以查看到Student.java中的有关成员变量和方法的定义。

8、构造函数：当你自己新创建了一构造函数时即进行了构造函数的重载时，还应该声明默认的构造函数，因为当你创建了新的构造函数时系统不会自动创建默认构造函数
    所以当你要创建一个不带参数的对象时，编译器会提示没有相应的构造函数与之对应。但当你创建对象是传了参数则不会提示出错。

9、this关键字的使用：
    (1)、当成员变量中的变量名与成员函数也包括构造函数中的形参名相同时，可在函数内使用this.x=x来引用成员数据并为成员变量赋值。
    (2)、需明确使用当前对象的句柄，this返回当前对象的引用。
        例如：public class Leaf {
              private int i = 0;
              Leaf increment() {
                i++;
                return this;
              }
              void print() {
                System.out.println("i = " + i);
              }
              public static void main(String[] args) {
                Leaf x = new Leaf();
                x.increment().increment().increment().print();
              }
            }
    (3)、在构建器里调用构建器：注意的是应该放在构造函数的最前面。
        例如：public class Flower {
              private int petalCount = 0;
              private String s = new String("null");
              Flower(int petals) {
                petalCount = petals;
                System.out.println(
                  "Constructor w/ int arg only, petalCount= "
                  + petalCount);
              }
              Flower(String ss) {
                System.out.println(
                  "Constructor w/ String arg only, s=" + ss);
                s = ss;
              }
              Flower(String s, int petals) {
                this(petals);
            //!    this(s); // Can't call two!
                this.s = s; // Another use of "this"
                System.out.println("String & int args");
              }
              Flower() {
                this("hi", 47);
                System.out.println(
                  "default constructor (no args)");
              }
              void print() {
            //!    this(11); // Not inside non-constructor!
                System.out.println(
                  "petalCount = " + petalCount + " s = "+ s);
              }
              public static void main(String[] args) {
                Flower x = new Flower();
                x.print();
              }
            }
        尽管可用this调用一个构建器，但不可调用两个   

10、static关键字的使用：
    Static关键字:
    通常只有创建了对象才能分配内存,才能够使用类中的方法.假如我要一段代码保存数据的内存或我要一个不从属任何对象的方法,则通过Static关键字实现.
     当你声明某种东西是static的时候,你的意思是这项数据或方法没有被连到任何一个类的实例.因此即使不创建这个类 的实例也可以使用这个static数据或方法.
     但是static的方法不能直接访问非static的成员或方法.
    static数据及方法的访问:
    class StaticTest
    {
        static int i=23;
    }
    （1）可以用两种方法使用变量i,
    一种使用类的对象StaticTest st1=new StaticTest();st1.i++;
    一种是直接使用类名.StaticTest.i++;
    注意:如果使用类的多个对象使用变量i时,改变其中一个另一个跟着改变,因为他们使用的是同一段内存.
    StaticTest st1=new StaticTest();
    StaticTest st2=new StaticTest();
    st1.i++;
    st2.i++;
   
     （2）特别注意：
    public class Point
    {
        int x;
        void output()
        {}
        static void output(int x)
        {
            this.x=x;//这里static声明的成员函数是不能访问非static的成员变量的。除非将x声明成：static int x;
        }
    }

    （3）将static变量也称为类变量，其他变量则可称为实例变量。同样有类方法，实例方法。
    要注意的是：在非static方法中是可以调用static方法和成员变量的。
    如main函数中的方法.
    public static void main(String[] args){
       System.out.println("slfsfsfsf");
    }
    因为out是System类中声明为static类型的对象
    另外main方法也是定义成static的，这是因为当类加载时并没有创建实例，而JAVA中都是以类为单元的，所以这里定义为static，便于不同类加载它。

11、final
    final int a=3;
    或final int a;
      Point()
      {
             //this(1,1);注意：this(1,1)一定要放在构造函数最前面。
             a=3;
      }
      Point(int x,int y)
      {
        a=3; //注意：如果final类型的常量在定义时没有初始化，那么在构造函数中初始化时需要注意，即所有构造函数中都要有初始化语句a=3;
      }
     即final声明一个常量并初始化，或先声明然后在构造函数中初始化。
     但是要注意的是：
        常量一般声明为static,即static final int a=3;这里因为声明的是static的不属于任何实例的，所以这时一定要在常量声明时初始化，不能在构造函数中初始化了。

12、继承性
    JAVA不允许类的多继承。C++当中是允许多继承的。当子类与超类中存在相同的方法时，超类的方法被隐藏，即超类对象调用超类中的方法，子类对象调用子类的方法。
    如：class Animal
        {
            int height ,weight;
            void sleep()
            {
                System.out.println(" Animal sleep");
            }
            void eat()
            {
                System.out.println(" Animal eate");
            }
        }

        class Fish extends Animal
        {
            void eat()
            {
                System.out.println(" Fish eate");
            }
        }

        class Integeration
        {
            public static void main(String[] args)
            {
                Animal an= new Animal();
                Fish fh = new Fish();
                an.eat();
                fh.eat();
            }
           
        }
        结果为： Animal eate
             Fish eate

13、super的使用
    super用于在子类中对父类的访问
            可以利用super来访问父类被子类隐藏的变量或方法。也就是说当父类与子类都有某一方法的定义时，如果我想在子类中调用父类中的这个方法，那么使用super来实现。
            如：class Cleanser {
                  private String s = new String("Cleanser");
                   public void scrub() { append(" scrub()"); }
                  public void print() { System.out.println(s); }
                  }
       
                public class Detergent extends Cleanser {
                  public void scrub() {
                    append(" Detergent.scrub()");
                    super.scrub(); // Call base-class version
                  }
                 
                  public static void main(String[] args) {
                    Detergent x = new Detergent();
                    x.scrub();
                    x.print();
                   }
                }
       
                   

14、继承的执行顺序及构造函数的调用过程：
    程序如下：
            class act1
            {
                act1(){
                System.out.println("act1 constructor");}
            }
       
            class act2 extends act1
            {
                act2(){
                System.out.println("act2 constructor");}
            }
       
            public class act3 extends act2
            {
                act3(){
                System.out.println("act3 constructor");}
                public static void main(String[] args)
                {
                    act3 x=new act3();
                }
            }
       
       
            结果如下：
            C:\java>java act3
            act1 constructor
            act2 constructor
            act3 constructor
    说明：在衍生类的构建器中，Java会自动插入对基础类构建器的调用。这里正是super关键字的用处所在：即在子类中隐藏了语句super。父类构造函数名()。

15、以下示例用带参数的构造函数来说明super在继承中调用构造函数时所起的作用。
                class act11
                {
                    act11(int i){
                    System.out.println("act11 constructor");}
                }
           
                class act12 extends act11
                {
                    act12(int i){
                        super(i);
                    System.out.println("act12 constructor");}
                }
           
                public class act13 extends act12
                {
                    act13(){
                        super(13);
                    System.out.println("act13 constructor");}
                    public static void main(String[] args)
                    {
                        act13 x=new act13();
                    }
                }
           
                结果为：
                C:\java>java act13
                act11 constructor
                act12 constructor
                act13 constructor
    说明：
    含有自变量的构建器
    例14中有自己默认的构建器；也就是说，它们不含任何自变量。编译器可以很容易地调用它们，因为不存在具体传递什么自变量的问题。
    如果类没有默认的自变量，或者想调用含有一个自变量的某个基础类构建器，必须明确地编写对基础类的调用代码。这是用super关键字以及适当的自变量列表实现的。
    注意区别super与this的使用，this用于在同一类中某一构造函数中调用另一构造函数；而super则不只限于构造函数，用于在继承类中调用父类中的具有相同特性的函数。
    super用来调用基类的带参数的构造函数时应该注意的地方：
            看下面两段代码：一个是在继承类中有super(i)调用基类带参数构造函数，另一个则没有，注意看他们的输出值。
                public class Test {
                    public static int i ;
                    public static void main(String[] args) {
                        TT t = new TT(23);
                        }
                    }   
                class T{
                    protected float j=2.0f;
                    public T(){
                        System.out.println("fater class constuctor");
                    }   
                    public T(int i){
                        System.out.println("fater class constuctor tt="+i);
                    }
                }
                class TT extends T{
                    public TT(){
                        System.out.println("child class contructor");
                    }   
                    public TT(int i){
                        super(i);
                        System.out.print("chiled="+i);
                    }
                       
                }
                输出结果为：
                fater class constuctor tt=23
                chiled=23
                再看：
                public class Test {
                    public static int i ;
                    public static void main(String[] args) {
                        TT t = new TT(23);
                        }
                    }   
                class T{
                    protected float j=2.0f;
                    public T(){
                        System.out.println("fater class constuctor");       //当没用用super(i)显式调用基类的构造方法的时候，JAVA虚拟机会自动找基类的无参构造函数。
                    }   
                    public T(int i){
                        System.out.println("fater class constuctor tt="+i);
                    }
                }
                class TT extends T{
                    public TT(){
                        System.out.println("child class contructor");
                    }   
                    public TT(int i){
                        //super(i);                           //作了注释
                        System.out.print("chiled="+i);
                    }
                       
                }
                输出结果为：
                fater class constuctor
                chiled=23
                无super(i)调用时，自动调用基类无参的构造方法，再执行自身的构造方法
               
                下面我把基类的无参构造方法注释掉：
                public class Test {
                    public static int i ;
                    public static void main(String[] args) {
                        TT t = new TT(23);
                        }
                    }   
                class T{
                    protected float j=2.0f;
                    /*
                    public T(){
                        System.out.println("fater class constuctor");
                    }   
                    */
                    public T(int i){
                        System.out.println("fater class constuctor tt="+i);
                    }
                }
                class TT extends T{
                    public TT(){
                        System.out.println("child class contructor");
                    }   
                    public TT(int i){
                        //super(i);
                        System.out.print("chiled="+i);
                    }
                       
                }
                提示报错：
                    Test.java:19: 找不到符号
                    符号： 构造函数 T()
                    位置： 类 T
                            public TT(){
                                      
   
16、java中文件名及public类名关系
            (1) 每个编译单元（文件）都只能有一个public类。每个编译单元有一个公共接口的概念是由那个公共类表达出来的。根据自己的需要，它可拥有任意多个提供支撑的“友好”类。但若在一个编译单元里使用了多个public类，编译器就会向我们提示一条出错消息。
            (2) public类的名字必须与包含了编译单元的那个文件的名字完全相符，甚至包括它的大小写形式。所以对于Widget来说，文件的名字必须是Widget.java，而不应是widget.java或者WIDGET.java。同样地，如果出现不符，就会报告一个编译期错误。
            (3) 可能（但并常见）有一个编译单元根本没有任何公共类。此时，可按自己的意愿任意指定文件名，不过应注意，在通过java命令执行的时候，后面应该跟：具有main方法的类名。

17、多态性
        动态绑定：指执行期间（而非编译期间）判断所引用对象的实际类型，根据其实际的类型调用相应方法。
                首先：多态性是通过覆盖父类的方法来实现的，在运行时通过传递的对象引用来调用相应的方法。多态性与方法的重载和覆盖是密不可分的。
                class Animal
                {
                    int height ,weight;
                    void sleep()
                    {
                        System.out.println(" Animal sleep");
                    }
                    void eat()
                    {
                        System.out.println(" Animal eate");
                    }
                }
           
                class Fish extends Animal
                {
                    void eat()
                    {
                        System.out.println(" Fish eate");
                    }
                }
           
                class Integeration
                {
                    static void fn(Animal an)
                    {
                        an.eat();
                    }
                    public static void main(String[] args)
                    {
                        Animal an;
                        Fish fh=new Fish();
                        an=fh;
                        Integeration.fn(an);
                    }   
                }
                结果为：Fish eate.
               
                类中通过eat方法的覆盖，及将Fish引用赋给Animal引用，当调用静态方法fn时，虽然参数类型为Animal，但实际传过来的是Fish的引用，调用的是子类Fish类中的eate方法；
                java利用其多态性输出结果为：Fish eate.
        在这里注意，假如Fish类中没有eate方法，那么结果将是输出Animal eate.
           
                java中：重载也称为编译时多态，覆盖称为运行时多态。
               
                >>>  对象的转型
                    规则：
                    1、一个基类的引用可以指向其子类的对象。 如：Animal a = new Dog();
                    2、一个基类的引用不可访问子类新增的成员变量或方法。
                                派生类新增的功能基类肯定看不到。。
                    3、可使用（引用变量 instanceof 类名）来判断该引用变量所"指向"的对象是否属于该类或该类的子类。
                    4、子类的对象可以当作基类来使用称向上转型upcasting,反之称为向下转型downcasting.
                        如下：Animal类，Dog类为子类
                            public class TestIns{
                                public static void main(String[] args){
                                    Dog d = new Dog("xiaohei","black");
                                    d.print();
                                    d.swim();
                                    Animal a = new Dog("xiaobai","white");
                                    a.print();
                                //    a.swim();                   //Animal a只认Dog类中从基类中继承出来的方法或成员，对swim()这一子类中新增的方法不可见。
                                }
                            }
                           
                            class Animal{
                                String name;
                                public Animal(String name){
                                    this.name = name;
                                }
                                    public void print(){
                                        System.out.println("name="+name);
                                }
                            }
                           
                            class Dog extends Animal{
                                String furColor;
                                public Dog(String name,String furColor){
                                    super(name);
                                    this.furColor = furColor;
                                }
                               
                                public void swim(){
                                    System.out.println("Dog swimming");
                                }
                                public void print(){
                                    System.out.println("name="+name+", furColor="+furColor);
                                }
                            }
                            输出结果：
                            name=xiaohei, furColor=black
                            Dog swimming
                            name=xiaobai, furColor=white
                           
                            父类引用指向子类对象
                            public class TestIns{
                            public static void main(String[] args){
                                Dog d = new Dog("xiaohei","black");
                                d.print();
                                d.swim();
                                System.out.println(a.furColor);
                                Animal a = new Dog("xiaobai","white");            //这里使用父类引用指向子类对象，但此时引用只把该对象当作普通的animal，即看不到dog的其他特性。
                                a.print();
                                //System.out.println(a.furColor);                //a无法访问子类的新成员。
                                //    a.swim();
                                Dog d1 = (Dog)a;
                                d1.swim();
                               
                                System.out.println(d instanceof Dog);
                                System.out.println(d instanceof Animal);
                                System.out.println(a instanceof Dog);
                                System.out.println(a instanceof Animal);
                               
                            }
                        }
                       
                        class Animal{
                            String name;
                            public Animal(String name){
                                this.name = name;
                            }
                                public void print(){
                                    System.out.println("name="+name);
                            }
                        }
                       
                        class Dog extends Animal{
                            String furColor;
                            public Dog(String name,String furColor){
                                super(name);
                                this.furColor = furColor;
                            }
                           
                            public void swim(){
                                System.out.println("Dog swimming");
                            }
                            public void print(){
                                System.out.println("name="+name+", furColor="+furColor);
                            }
                        }
                       
                        可以在方法的参数里面使用父类的引用，但传入一个子类的对象。这样不管多少个子类对象都可以得到执行。
                       
                >>>    再看下例：
                   
                            class Animal{
                                String name;
                                Animal(String name){
                                    this.name=name;
                                }
                                public void enjoy(){
                                    System.out.println("动物叫。。。。");
                                }   
                            }
                           
                            class Cat extends Animal{
                                String furColor;
                                Cat(String name,String furColor){
                                    super(name);
                                    this.furColor = furColor;
                                }
                                public void enjoy(){
                                    System.out.println("猫叫。。。。。");
                                }
                            }
                           
                            class Dog extends Animal{
                                String DurColor;
                                Dog(String name,String DurColor){
                                    super(name);
                                    this.DurColor = DurColor;
                                }
                                public void enjoy(){
                                    System.out.println("狗叫。。。。");
                                }
                            }
                           
                            class Laddy{
                                String name;
                                Animal pet;
                                Laddy(String name,Animal pet){
                                    this.name = name ;
                                    this.pet = pet;
                                }
                                public void mypetEnjoy(){
                                    pet.enjoy();
                                }
                            }
                           
                            public class TestDuotai{
                                public static void main(String[] args){
                                    Cat c = new Cat("cat","blue");
                                    Dog d = new Dog("dog","black");
                                    Laddy l1= new Laddy("limei",c);
                                    Laddy l2 = new Laddy("zhanli",d);
                                    l1.mypetEnjoy();
                                    l2.mypetEnjoy();
                                }
                            }
                            输出结果为：
                            猫叫。。。。。
                            狗叫。。。。
                           
                            由上例子可以看出实现多态要有三个条件：
                            要有继承
                            要有重写
                            要有父类引用指向子类对象。
           
            >>> 接口引用指向对象的时候也发生了多态。如下：
                        interface Singer{
                            public void sing();
                            public void sleep();
                        }
                        class Student implements Singer{
                            public void sing(){
                                System.out.println("student singer");
                            }
                            public void sleep(){
                                System.out.println("student sleep");
                            }
                            public void study(){
                                System.out.println("student study");
                            }
                        }
                       
                        public class TestInterface{
                            public static void main(String[] args){
                            Student s = new Student();
                            s.sing();
                            s.sleep();
                            s.study();
                           
                            Singer s1 = new Student();
                            s1.sing();
                            s1.sleep();
                            //s1.study();   跟类的继承时父类的引用指向子类对象一样，看不到子类中的新的方法。
                            //这里把s1只当作Singer只看得到sing()和sleep();
                        }
                        }

18、instanceof判断引用是否为类的实例。
                class Animal
                {
                    int height ,weight;
                    void sleep()
                    {
                        System.out.println(" Animal sleep");
                    }
                    void eat()
                    {
                        System.out.println(" Animal eate");
                    }
                }
           
                class Fish extends Animal
                {
                   
                }
           
                class Integeration
                {
                    static void fn(Animal an)
                    {
                        an.eat();
                    }
                    public static void main(String[] args)
                    {
                        Animal an=new Animal();
                        Fish fh=new Fish();
                        //an=fh;                             //(1)
                        if(fh instanceof Animal)
                            System.out.println("fh is instance of animal");
                        else
                            System.out.println("fh is not instance of animal");
                        if(an instanceof Fish)
                            System.out.println("an is instance of fish");
                        else
                            System.out.println("an is not instance of fish");
                           
                    }   
                }
                结果为：
                fh is instance of animal
                an is not instance of fish
                取消注释（1）得结果：
                fh is instance of animal
                an is instance of fish
19、包
            源码：
            package com.mybook;
            public class Book
            {
                public static void main(String[] args)
                {
                    System.out.println("java package");
                }
            }
            JAVA的包与文件系统中的目录结构要求对应：
            那么也就是说com.mybook我要在对应的目录中创建com和mybook文件夹。可利用命令javac -d . Book.java,表示在Book.java所在目录进行编译，同时将编译的结果，即生成的Book.class文件置于com文件夹下的mybook文件夹下。
            当然也可以将class文件生成在其它目录中：javac -d d:\  Book.java,即将在d:\com\mybook下生成Book.class文件。
20、类、变量、方法的修饰符
                   (1) 类的修饰符：
                    表示类的访问权限(public,private，default package  注意：类没有protected修饰符)和一些其他特性(abstract,final等)。
                如果类没有声明任何表访问权限的修饰符则为默认包权限。即同一包中的类可以互相访问。如果从另一包中访问这个包中的类，则此类需声明为public的。如果类声明为private的，则只有类的创建者才有权限使用，
                我们一般不这样声明，如果想别的类不能访问此类，大可将此类的构造函数声明为private的。
                    final类：final类表示此类为最终类，即此类不能被派生或覆盖。如java.lang.String类即为final类。
                如：编写类Ex1.java
                    import java.lang.*;
                    public class Ex1 extends String
                    {
                        public static void main(String[] args)
                        {
                            System.out.println("sf");
                        }
                    }
                    运行结果为：
                    Ex1.java:2: 无法从最终 java.lang.String 进行继承
                    public class Ex1 extends String                   
                    1 错误
                    (2) 方法的修饰符
                    方法声明格式为：[<修饰符>]<返回类型><方法名>（[<参数>]）[throws <异常类>]{}
                        如：public static final int Book(int x,int y) throws IOException{...}
                    访问权限(public,protected,private,default),方法的其它修饰符（static, final,abstract,native,synchronized）
                    图示访问权限：
                        public        protected       default       private
                    同类      Y                Y              Y            Y
                    同包      Y                Y              Y            N
                    子类      Y                Y              N            N
                    不同包非继承      Y           N          N           N
                关于方法的访问权限修饰符21中仍有说明。
                    方法的其它修饰符：
                    1、static关注第10个学习点。
                    2、final方法：
                        final方法是为确保方法在继承的过程中保持不变，即不能被子类改变（覆盖）。
                        类中所有private和static方法自然成为final方法。
                    3、抽象方法与抽象类：
                        （1）在类中没有方法体的方法即为抽象方法，含有抽象方法的类即为抽象类；
                            package com.my;
                            public abstract class My //有抽象方法的类为抽象类
                            {
                                public abstract  void fn();//抽象方法；
                                public static void main(String[] args)
                                {
                                    System.out.println("my ");
                                }
                            }
                        （2）如果一个子类没有实现抽象基类中的任何抽象方法，则子类也为抽象类。
                            父类：
                            package com.my;
                            public abstract class My
                            {
                                public abstract  void fn();
                                public static void main(String[] args)
                                {
                                    System.out.println("my ");
                                }
                            }
                            子类：
                            package com.my;
                            public class Msun extends My
                            {
                               
                                public static void main(String[] args)
                                {
                                    System.out.println("msun ");
                                }
                            }
                            编译：javac -d . My.java
                                  javac -d . Msun.java
                                  java com.my.My
                                  java com.my.Msun     //出错提示：msun.java:2: com.my.Msun 不是抽象的，并且未覆盖 com.my.My 中的抽象方法 fn()
                                  即：如果父类为抽象类，则子类要么声明为抽象类，要么覆盖父类的抽象方法。
                                  修改子类如下：
                            子类：
                            package com.my;
                            public abstract class Msun extends My
                            {
                               
                                public static void main(String[] args)
                                {
                                    System.out.println("msun ");
                                }
                            }
                            或
                            package com.my;
                            public class Msun extends My
                            {   
                                public void fn()
                                {System.out.println("overrite ");}
                               
                                public static void main(String[] args)
                                {    Msun ms = new Msun();
                                    ms.fn();
                                    System.out.println("msun ");
                                }
                            }
                        （3）我们可以将没有包括任何抽象方法的类声明为抽象类，以避免由这个类产生的任何对象。
                    4、native方法
                        JNI:java native interface
                        使用sun网站上下载的tutorial,目录下有native 1.1,打开index.html
                        指南里有具体的写一个java native 方法的步骤。
                        HelloWorld.java－>HelloWorld.class->(javah -jni HelloWorld)HelloWorld.h+stdio.h具体操作见文档及孙鑫视频教程lesson3f.swf
                        static
                        {
                            System.out.println("sf");
                        }
                        //静态代码块。

21、关于protected访问控制符的说明
                    可访问性：    public > protected > package >private
                    1.protected 访问控制符既能被用于方法又能用于成员变量。（不用于类）
                    2.声明为protected的方法和成员变量能被同一个包里的所有类所访问。
                    3.声明为protected的方法和成员变量能被该类的子类所访问，子类和父类可以不在一个包中。
                    4.不在同一个包中的子类要访问父类的方法或成员变量有2种方式.　　
                　　     (1) 直接访问父类的protected方法或成员变量。
                          // 定义父类；
                          package packfather;
               
                          public class Father(){
                                  protected int var;
                          }
               
                          // 定义子类一；
                          package packsun;
                          import packfather.Father;
                          public calss Sun1 extends Father{
                                public void set(int varsun1){
                                        // 可以直接访问父类protected变量；
                                        var = varsun1;
       

评论

1 楼 ipuhua 2012-03-29  

你的总结非常好，不是那种廉价的复制粘贴类型的。对我帮助很大。辛苦了，谢谢！