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

原创 2006年05月31日 12:38:00

 

***对象作为参数传递***
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类<br>
 * Description: 通过engineer类来说明java中的文档注释<br>
 * Copyright: (C) 2003 www.it315.org<br>
 * Company: IT人资讯交流网<br>
 * @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)
 {
  }
}
-----------------------------------------------------------------
<br> 在html中换行,而带有@标志的属性会自动换行,结尾就省略了<br>
@author <作者姓名>  用于类的说明,表示这个java程序的作者
@version<版本信息>  用于类的说明,表示这个java程序的开发版本。
@param<参数名称><参数说明> 用于方法的说明,表示方法所引入的参数,及其参数对应的说明
@return<返回值说明> 用于方法的说明,表示此方法的返回值表示的意义。
----------------------------------------------------------------
在dos下 存放文件的目录下输入
javadoc -d engineer -version -author engineer.java
javadoc 就会生成这个类的说明文件
-d 用来制定说明文件存放的目录
engineer 为说明文件所存放的目录名;
-version 代表要求javadoc程序在说明文件中加入版本信息
-author 表示要求javadoc程序在说明文件中加入作者信息

相关文章推荐

黑马程序员——面向对象(一)---面向对象、函数的参数传递、static、内部类、文档注释

面向对象(一) 第一部分 面向对象 一.理解面向对象的概念 1.面向过程: 在一个结构体中定义窗口的大小,位置,颜色,背景等属性,对窗口操作的函数与窗口本身的定义没有任何关系,如HideWin...

黑马程序员---java学习笔记之面向对象:静态内部类

1、内部类在外部类的成员位置上时,就可以用修饰类成员的修饰符修饰该内部类         a):private修饰内部类,该类就被封装,不能被外部其他类直接访问;         b):static修...

《黑马程序员》 静态方法中不能new内部类的实例对象的总结

------- android培训、java培训、期待与您交流! ---------- class Test{ public void main(String[] args){ A test...
  • xfgzss
  • xfgzss
  • 2014年03月29日 11:56
  • 848

静态方法中不能new内部类的实例对象的总结

原文   http://blog.csdn.net/zhizguoz/article/details/22483535 class Test{ public void main(String...
  • a010655
  • a010655
  • 2015年05月21日 20:09
  • 1030

JAVA学习.JAVA对象构建内存理解&静态方法和变量的理解和使用.

JAVA学习.JAVA对象构建内存理解&静态方法和变量的理解和使用. .操作系统为程序的运行分配所需要的内存,如果内存允许的情况下,一般进程申请多少内存操作系统就分配给多少内存。 进程和程序的概念基本...

C#学习笔记之六 类定义中static关键字的用法暨C#中静态变量的意义与使用

在定义类中的一个成员变量的时候,如果使用了static 关键字。那么这个类就只会 有这一个变量,称它是静态变量,它是属于这个类的,是类的专有的静态变量,而不是属于类的实例(对象)的。那么,属于这个类的...
  • CGGUANG
  • CGGUANG
  • 2016年11月06日 21:47
  • 1202

二维数组的定义(动态初始化、静态初始化)、初始化格式及其操作、java中的参数传递方式,面向对象的基本概念

java中的二维数组 数组中的元素是 一维数组 ,这样的数组叫做二维数组 格式 动态初始化:数据类型[][] 变量名 = new 数据类型[m][n] 静态初始化:数据类型[][] 变量名 =...

java 程序加载过程---3--类中申明同时申明类的静态对象 创建类的实例 访问类的静态变量 调用类的静态方法 使用反射方法 初始化类的子类对象 直接使用java.exe 调用某个类

java 程序加载过程---3---申明类的静态对象===》常见的应用是单例模式(饿汉式) 大家知道,只要打开任何一个开源软件,看到很多在类申明时候同时申明一个静态对象,此种情况JVM是如何加载的呢?...

黑马程序员-Java面向对象II(抽象类、接口、参数传递修饰符和内部类问题)

Java面向对象II(抽象类、接口及参数传递问题)

day06-1static 使用静态方法并生成文档取最值,选择排序,冒泡排序,位置交换,打印数组元素

/* public static void main(String[] args) 主函数:是一个特殊函数,作为程序的入口,可以被jvm调用 主函数的定义: public:代表着该函数的访问权限是...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:java学习笔记(四)----对象、数组作为参数传递,静态变量、静态方法的使用,内部类,使用文档注释
举报原因:
原因补充:

(最多只允许输入30个字)