java日志

double temp=3.5;  //可以编译通过

float temp1=3.5f;  //末尾加f才可

所以一般就用double型。

    /**昨天习惯性的用了float，编译器总是提示丢失精度，在C++中从来没有这种情况，真是让我摸不到头脑，百度一下才知道还有这个规定，真是怕了乌龟的屁股。*/

二、java中非静态方法可以直接引用静态方法（变量）以及非静态方法（变量），静态方法可以直接引用静态方法（变量），但是静态方法不能直接引用非静态方法（变量），需要先定义一个非静态方法（变量）所属的对象，然后用对象来引用该非静态方法（变量）。例如：

public class A

{

    String x;

    static String y="Ping";

    void a1Function()

    {

        System.out.println("a1Function called");

    }

    static void a2Function()

    {

        System.out.println("a2Function called");

    }

    public static void main(String args[])

    {

        //a1Function(); //(1)错误，无法从静态上下文中引用非静态方法 a1Function()

        A aa=new A();

        aa.a1Function();

        a2Function();  //(1)可以直接引用静态方法 a2Function()

        //System.out.println("x="+x); //(1)错误，无法从静态上下文中引用非静态变量 x

        System.out.println("y="+y);   //(1)可以直接引用静态变量 y

        System.out.println("z="+B.z);

        /*(1)可以直接引用class B中的静态变量z

           (2)必须为B.z，上一行中因为是引用主函数引用主类中的静态变量所以可以省略类

        名，直接引用y，也可写成A.y 

        */

        B.b1Function(); //(1)

        B bb=new B();

        bb.b2Function(); //(1)

    }

}

class B  //（3）不能为public，一个文件中只能有一个公共类，且文件名与公共类名必须相

{          //同，java中包含主函数的主类必须是公共类

    static String z="Zhou";

    static void b1Function()

    {

        System.out.println("b1Function called");

    }

    void b2Function()

    {

        System.out.println("b2Function called");

    }

}

注释中的(1)(2)(3)分别代表三类问题。

/**经过昨天一天的摸索，终于弄清楚java中动静态的问题了。回过头来想一下，一开始觉得很费解的规定其实都是有深层的含义的。静态表示属于类，在类定义的同时它就已经存在了，所以可以直接拿来使用。而动态的则要在用类定义对象之后，new一个空间给它才可以使用。正是这样，才有实际的意义。其实这些在C++中已经知道，但是就是被代码给搞糊涂了，忘了隐藏在代码后面的本质。

     本来想写个例子来说明一下（1），结果一下子又引出了（3），新接触一种语言需要弄清楚的地方可真多啊...*/

一、Java中，方法的参数可以是基本类型，也可以是复合类型（类、数组、接口）。基本类型作为方法参数时，参数传递的是变量值，而不是变量地址值。因此，不能改变调用方法中的参数值。复合类型作为方法参数时，参数传递的是对象的地址值，因此，对参数的改变会影响到原来的参数值。例如:

class Test1

{

    int x;

    Test1(int i)

    {

        x=i;

    }

    void changeX(Test1 temp)

    {

        temp.x=10;

    }

    public static void main(String args[])

    {

        Test1 t=new Test1(5);

        System.out.println("t.x="+t.x);

        t.changeX(t);

        System.out.println("t.x="+t.x);

    }

}

程序结果:

t.x=5

t.x=10

/*************************华丽的mark*****************************/

二、不光是对象作为方法参数时与C++中情况不同，就算只是两个对象之间的赋值，也是传递地址。例如:

class Test

{

     int x;

     Test(int i)

     {

        x=i;

     }

     public static void main(String args[])

     {

        Test t1=new Test(5);

        Test t2=new Test(10);

        t1=t2;

        System.out.println("t1.x="+t1.x);

        System.out.println("t2.x="+t2.x);

        t1.x=20;

        System.out.println("t1.x="+t1.x);

        System.out.println("t2.x="+t2.x);

        t2.x=30;

        System.out.println("t1.x="+t1.x);

        System.out.println("t2.x="+t2.x);

    }

}

程序结果:

t1.x=10

t2.x=10

t1.x=20

t2.x=20

t1.x=30

t2.x=30

/*************************华丽的mark*****************************/

三、子类对象可以给父类对象赋值，反之则不可（编译能通过，但不能运行），具体原因不清楚，但是直观的想子类对象中包含更多的变量和方法，这样赋值没有风险。子类对象给父类对象赋值后，其实和（二）中的情况一样，也是把地址传递。例:

class A

{

    int x;

}

class B extends A

{

}

class Test

{

    public static void main(String args[])

    {

        A a=new A();

        B b=new B();

        b.x=5;

        a=b;

        System.out.println("a.x="+a.x);

        a.x=10;

        System.out.println("b.x="+b.x);

    }

}

程序结果:

a.x=5

b.x=10

    a=b后，a.x的改变影响了b.x的值，说明a和b的地址值是一样的（或者说a是b的引用）。

异常和异常处理

    （1）try{}中一遇到异常（包括系统定义的异常和自己throw一个异常），程序立刻跳转到catch，并且try{}中剩下的程序不会再执行。这样做防止了后面再有异常，从而保证了catch到的异常类对象的唯一性。换句话说，执行一次try{} catch语句只能捕捉到一个异常，不能同时处理try{}中的多个异常。

   （2） 可以有多个catch，按先后顺序比对异常，一旦合适，则下面的catch都不执行。通常可以这样写:

    catch(Exception e)

    {

        System.out.println(e.toString());

    }

    不管是系统定义的异常，还是自己定义的异常，都是Exception的子类，这样只要try块中抛出异常，则就会被catch到，而且会调用抛出异常相应的toString()方法（因为形参是父类对象，实参是子类对象，子类对象属于父类范畴）。

   （3） 不论try块中是否产生异常事件，也不论哪个catch方法被执行，finally{}中的程序都会被执行。

/******************************mark*****************************/

例一:

public class Exam6_6

{

  public static void main(String args[])

  {

    try

    {

      int s=sub(1,2);

      System.out.println("1-2="+s);

    }

    catch(numException e)

    {

      //System.out.println(e);      //结果一样的

      System.out.println(e.toString());

    }

    try

    {

      int s=sub(6,3);

      System.out.println("6-3="+s);

    }

    catch(numException e)

    {

      System.out.println(e.toString());

    }

  }

  static int sub(int a, int b) throws numException

  {

    if(a    {

      numException e=new numException(a,b);

      throw e;

    }

    return a-b;

  }

}

class numException extends Exception

{

  private int x,y;

  numException(int a, int b)

  {

    x=a;

    y=b;

  }

  public String toString()

  {

    return "numException: "+x+"<"+y;

  }

}

程序运行结果:

numException: 1<2

6-3=3

例二:

public class Exam6_9

{

  public static void main(String args[])

  {

    try

    {

      int a=2,b=3;

      if(a      {

        numException e=new numException(a,b);

        throw e;

      }

      int s=sub(a,b);

      System.out.println(a+"-"+b+"="+s);

    }

    catch(numException e)

    {

      System.out.println(e.toString());

    }

    try

    {

      int a=5,b=3;      //说明try{}中定义的变量只在其大括号内有效

      if(a      {

        numException e=new numException(a,b);

        throw e;

      }

      int s=sub(a,b);

      System.out.println(a+"-"+b+"="+s);

    }

    catch(numException e)

    {

      System.out.println(e.toString());

    }

  }

  static int sub(int a, int b)

  {

    return a-b;

  }

}

class numException extends Exception

{

  private int x,y;

  numException(int a, int b)

  {

    x=a;

    y=b;

  }

  public String toString()

  {

    return "numException: "+x+"<"+y;

  }

}

程序运行结果:

numException: 2<3

5-3=2

    注意比较其中sub函数的不同之处，例一中异常在sub函数中抛出，例二则是在main函数中抛出异常。

/******************************mark*****************************/

例三:

public class Exam6_8

{

  public static void main(String args[])

  {

    int array1[]={56,,24,34,40};

    int array2[]={4,0,8,7};

    int i;

    for(i=0;i    {

      try

      {

      //  System.out.println(i);

        if(array1[i]%array2[i]!=0)

        {

          NumException e=new NumException(array1[i],array2[i]);

          throw e;

        }

      //  System.out.println(i);

        System.out.println(array1[i]+"/"+array2[i]+"="+array1[i]/array2[i]);

      }

      catch(Exception e)

      {

        System.out.println(e.toString());

      }

      /*catch(NumException e)   //不能加上这几行，否则报错

      {

        System.out.println(e.toString());

      }*/

    }

  }

}

class NumException extends Exception

{

  private int a,b;

  NumException(int a, int b)

  {

    this.a=a;

    this.b=b;

  }

  public String toString()

  {

    return a+"不能整除"+b;

  }

}

程序运行结果:

56/4=14

java.lang.ArithmeticException: / by zero

24/8=3

34不能整除7

java.lang.ArrayIndexOutOfBoundsException: 4

    这是一个反复抛出异常的例子，包括系统定义的异常和自定义的异常。其中包括许多知识点，比如:

（1）抛出系统定义的异常不用throw，而系统自己会根据条件来自动抛出，例如除数为0、数组下标越界等等。而用户自定义的异常则需要显示的throw才可以。

（2）在catch异常时要注意，可以每个异常都自己定义一个catch，不过为了简便可写成这样

      catch(Exception e)

      {

        System.out.println(e.toString());

      }

这个时候要注意，不能再在下面写

      //用numException举例

      //不能加上这几行，否则报错

      catch(NumException e)   

      {

        System.out.println(e.toString());

      }

因为numException是Exception的子类，如果有numException类的异常被抛出，则会被第一个catch到，这样重复定义会报错。