java对象、数组作为参数传递,静态变量、静态方法的使用,内部类,使用文档注释

java学习笔记(四)----对象、数组作为参数传递，静态变量、静态方法的使用，内部类，使用文档注释

2009-10-15 20:21

＊＊＊对象作为参数传递＊＊＊

class passparam

{ int x;

public static void main(String[] args)

{ passparam obj = new passparam();

obj.x=5;

change(obj);

System.out.println(obj.x);

//如果change方法不是静态的，想调用它就得写成new passparam().change(obj);

}

public static void change(passparam obj) //如果这个函数前面没加static编译出错，因为非静态方法，不能被静态方法直接调用，main 是一个静态方法。

{ obj.x=3;}

}

结果：3

＊＊＊数组作为参数传递＊＊＊

class passparam

{ int x;

public static void main(String[] args)

{ passparam obj = new passparam();

int []x=new int[1];

x[0]=5;

change(x);

System.out.println(x[0]);

}

public static void change(int[] x)

{ x[0]=3; }

}

结果：3

＊＊＊静态变量、静态方法的使用＊＊＊

静态变量相当于全局变量

class Chinese

{ static string country="中国"; //如果改为private static string country="中国" 下面的两处调用，就会出错

String name;

int age;

static void sing()

{ System.out.println("啊~~")

void singOurCountry()

{ System.out.println(country);

sing();

}

}

class TestChinese

{ public static void main(String[] args)

{ System.out.println(Chinaese.country); //static 静态变量可以直接引用

Chinese ch1=new Chinese();

ch1.singOurCountry();

System.out.println(ch1.country);

Chinese.sing(); //静态方法的引用

new.Chinese.sing(); // 用对象引用方法

}

}

--------------------------------

class Chinese

{ private static int count=0; //定义一个静态整形变量

static //静态代码块类在第一次使用时，初使化

{ count=2; //这个类在第一次使用时，count被初使化

System.out.println("static code")

}

String name;

int age;

public Chinese()

{ System.out.println(++count); }

}

class TestChinese

{ public static void main(String[] age){

System.out.println("static begin")

new Chinese();

System.out.println("end")

new Chinese();

new Chinese();

}

}

输出结果为

static begin

static code

3

end

4

5

------------------------------------

＊＊静态方法注意：

1、在静态方法里只能直接调用同类中其它的静态成员（包括变量和方法）。这是因为，对于非静态方法和变量，需要先创建类的实例对象后

才可使用，而静态方法在使用前不用创建任何对象。

2、静态方法不能以任何方式引用this和super关键字。与上面的的道理一样，因为静态方法在使用前不用创建任何实例对象，当静态方法被

调用时，this所引用的对象根本就没有产生。

3、main()方法是静态的，因此JVM在执行main方法时不创建main方法所在类的实例对象，因而在main()方法中，我们不能直接访问该类中的

非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员。

class B{

public void b(){ System.out.print("000");}

public static void e(){}

public void c(){b();

e();

} //类中的非静态方法可以调用该类中的其它非静态方法，和静态方法

}

class A{

public static void main(String[] args){

new B().c();

}

}

----------------------------------------

＊＊静态代码块

1、一个类中可以使用不包含在任何方法中的静态代码块（static block），当类被载入时，静态代码块被执行，且只被执行一次,静态块经常

来进行类属性的初始化。

2、类中的静态代码块被自动执行，尽管我们产生了类的多个实例对象，但其中的静态代码块只被执行了一次。当一个程序中用到了其他的类

，类是在第一次被使用的时候才被装载，而不是在程序启动时就装载程序中所有可能要用到的类。

---------------------------

＊＊＊单态设计模式＊＊＊使类在内存中只创建一个实例对象

class Chinese

{

private static Chinese objRef = new Chinese(); //这里必须用static，由于1、下面是用静态方法调用2、如果不用static就会陷入死

循环中，因为每创建一个objRef对象，就会重新载入Chinese类，然后又调用objRef类。

private static int count=0;

public static Chinese getInstance() //Chinese 为这个方法的返回类型, 这个方法是用静态方法来调用静态变量

{ return objRef; }

private Chinese() //单态设计模式要把构造函数设为私有的

{ System.out.println(++count); }

}

class TestChinese

{ public static void main(String[] age){

Chinese obj1 = chinese.getInstance();

Chinese obj2 = chinese.getInstance();

System.out.println(obj1==obj2); //返回结果为true

new Chinese(); //此处出错，因为构造函数已经是私有的了，所以不能再这样定义对象了。

}

}

注意：1，构造函数必须设为private

2, 类里面定义的对象必须是private，static,也可以加上final

3, 类里面要有一个调用对象的类，这个类必须是public,static,和类形是这个类的名,类中的其它要调用的方法还用public

--------------

单态设计模式：所谓类的单态设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供

一个取得其对象实例的方法，如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造方法的访问权限设置为private，这

样，就不能用new操作符在类的外部开始产类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调

用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定

义成静态的。

--------------------------------------------------------

＊＊＊嵌套类＊＊＊

1.嵌套类可以直接访问嵌套它的类成员，包括private成员，但是，嵌套类的成员却不能被嵌套它的类直接访问。

2.在类中直接定义的嵌套类的使用范围，仅限于这个类的内部，也就是说，A类里定义了一个B类，那么B为A所知，却不被A的外面所知。内部类

的定义和普通类的定义没什么区别，它可以直接访问和引用它的外部类的所有变量和方法，就像外部类中的其他非static成员的功能一样，和

外部类不同的是，内部类可以声明为private或protected.

3.内部类可以用static来修饰，这样相当于是一个外部定义的类，它的用法就和外部类一样了，所以static的内部类中可声明static成员，static的内部类不能再使用外层封装类的非static的成员变量，staic嵌套类很少使用.

class Outer

{ int outer_i=100;

void test()

{ Inner in=new Inner();

in.display();

}

class Inner

{ void display()

{ System.out.println("display: outer_i="+outer_i); }

}

}

class InnerClassDemo

{ public static void main(String[] args)

{ Outer outer=new Outer();

outer.test();

}

}

输出结果：display: outer_i=100

------------------------------------------------------------------

经验：当一个类中的程序代码要用到另外一个类的实例对象，而另外一个类中的程序代码又要访问第一个类中的成员，将另外一个类做成第一

个类的内部类，程序代码就要容易编写得多，这样的情况在实际应用中非常之多!

---------------------------------------------------------------------

***如果函数的局部变量(函数的形参也是局部变量)，内部类的成员变量，外部类的成员变量重名，我们应该按下面的程序代码所使用的方式来

明确指定我们真正要访问的变量。

pulic class Outer

{ private int size;

public class Inner

{ private int size;

public void doStuff(int size)

{ size++; //引用的是doStuff函数的形参

this.size++; //引用的是Inner类中的成员变量

Outer.this.size++; //引用的Outer类中的成员变量

}

}

}

----------------------------------------------

****内部类如何被外部引用****

内部类也可以通过创建对象从外部类之外被调用，只要将内部类声明为Public即可。

class Outer

{ private int size=10;

public class Inner //被外部引用，必须声明为public

{ public void doStuff()

{ System.out.println(++size); }

}

}

public class TestInner

{ public static void main(String[] args)

{ Outer a =new Outer();

Outer.Inner b=a.new Inner();

b.doStuff();

}

}

--------------------------------------------------

****方法中定义的内部类****

class Outer

{ int outer_i=100;

void test()

{ for (int i=0;i<5;i++)

{ class Inner //方法中定义的内部类

{ void display()

{ System.out.println("display: outer_i="+outer_i);}

}

Inner inner=new Inner();

inner.display();

}

}

}

class InnerClassDemo

{ public static void main(String args[]){

Outer outer=new Outer();

outer.test();

}

}

结果：

display: outer_i=100

display: outer_i=100

display: outer_i=100

display: outer_i=100

display: outer_i=100

*在方法中定义的内部类只能访问方法中的final类型的局部变量，因为用final定义的局部变量相当于是一个常量，它的生命周期超出方法运行

的生命周期。

class InOut

{ String str=new String("Between");

public void amethod(final int iArgs)

{ int it315;

class Bicycle

{ public void sayHello()

{ System.out.println(str);

System.out.println(iArgs);

}

}

}

}

在内部类中的sayHello方法中，我们可以访问变量iArgs和str,但不能访问it315

------------------------------------------------------------

*****使用文档注释******

对于类的说明应在类定义之前，对于方法的说明应在方法定义之前。

import java.io.*;

/**

* Title: engineero类

* Description: 通过engineer类来说明java中的文档注释

* Copyright: (C) 2003 https://www.360docs.net/doc/907106934.html,

* Company: IT人资讯交流网

* @author 张孝祥

* @version 1.00

*/

public class engineer

{

public String Engineer_name;

/**

* 这是engineer对象的构造函数

* @param name engineer的名子

*/

public engineer(String name)

{

}

/**

* 这是repairing方法的说明

* @param sum 需要修理的机器总数

* @param alltime需要修理的总时间

* @return Repairing的数量

*/

public int repairing (int sum, int alltime)

{

}

}

-----------------------------------------------------------------

在html中换行，而带有@标志的属性会自动换行，结尾就省略了

@author <作者姓名> 用于类的说明，表示这个java程序的作者

@version<版本信息> 用于类的说明，表示这个java程序的开发版本。

@param<参数名称><参数说明> 用于方法的说明，表示方法所引入的参数，及其参数对应的说明@return<返回值说明> 用于方法的说明，表示此方法的返回值表示的意义。

----------------------------------------------------------------

在dos下存放文件的目录下输入

javadoc -d engineer -version -author engineer.java

javadoc 就会生成这个类的说明文件

-d 用来制定说明文件存放的目录

engineer 为说明文件所存放的目录名;

-version 代表要求javadoc程序在说明文件中加入版本信息

-author 表示要求javadoc程序在说明文件中加入作者信息