java有关类的程序_Java 常用类

java.applet包含一些用于创建java小应用程序的类。

java.awt包含一些用于编写与平台无关的图形界面(GUI)应用程序的类。

java.io包含一些用作输入输出(I/O)处理的类。

java.lang包含一些java语言的基本类与核心类，如String Math Integer System Runtime

提供常用的功能，这个包中的所有类是被隐式导入的。

java.net包含用于建立网络连接的类，与java.io同时使用完成与网络有关的读写。

java.util包含一些实用工具类和数据结构类。

String

java.lang.String

public final class String 不能再有派生类。

String 对象是不可变的，所以可以共享它们。例如：

String str = "abc";

等效于：

char data[] = {'a', 'b', 'c'};

String str = new String(data);

下面给出了一些如何使用字符串的更多例子：

System.out.println("abc");

String cde = "cde";

System.out.println("abc" + cde);

String c = "abc".substring(2,3);

String d = cde.substring(1, 2);

String 类包括的方法有：检查序列的单个字符；比较字符串；搜索字符串；提取子字符串；创建字符串副本，在该副本中，所有的字符都被转换为大写或小写形式。大小写映射基于 Character 类指定的 Unicode Standard 版本。

substring()

"hamburger".substring(4, 8) returns "urge"

"smiles".substring(1, 5) returns "mile"

String构造方法

String str1=new String("abc");

java的基本数据类型

boolean,byte,short,int,long,char,float,double

其余的都是引用类型。String和arry都是引用类型

"=="是比较两个变量的值是否相等。

"equals"是比较两个对象变量所代表的对象的内容是否相等。

定义变量是在栈内存分配一个名称，new是在堆内存分配空间创建对象。

引用实际上是对象的首地址，将首地址附给变量名，所以栈内存所存放的是变量的首地址。

equals

public boolean equals(Object anObject)

比较此字符串与指定的对象。当且仅当该参数不为 null，并且是表示与此对象相同的字符序列的 String 对象时，结果才为 true。

覆盖：

类 Object 中的 equals

如果 String 相等，则返回 true；否则返回 false。

String str1="abc";

int i=3;

System.out.println(str1+i);

输出abc3;

字符串对象和整形变量相加；

字符串对象可以和任何类型的变量相加。

int i=3;

float f=1.5f;

char ch='f';

boolean b='false';

System.out.println("as"+i+f+ch+b);

针对String类的+ 和+=是唯一重载的运算符。

String类对象是常量对象。

String str="abc";

str="def";

这样只是在str的栈内存当中值是def的引用；所以堆内存的abc是垃圾内存。

当内存不足时要回收内存。实际上str的值是不改变的。

在处理大量字符串的程序中，通常用StringBuffer来代替String类。

StringBuffer类对象的应用。主要是append和insert和toStirng方法。

x=new StringBuffer().append("a").append("4").append("c").toString();

常用方法：

append();

insert();

toString();

capacity();

charAt(int index);

delete()

deleteCharAt();

reverse();反序函数；

java.awt

awt是abstract window talke

GUI是graghic user interface

数组

函数的参数是数组的时候。

num.length是数组的元素个数，并不是数组占内存的大小。

int [] num=new int[3];

num=null;把他保存的引用清除。

没有任何变量保存的引用，首地址。

使堆内存成为垃圾内存。

转换垃圾内存，把保存引用的对象附值为空null。

对于对象而言，在不使用对象的时候，可以把他置空，这样他所占有的内存变为垃圾内存。

这样在需要使用的内存的时候编译器就会释放对象所占有的堆内存。

使用引用类型数组。

定义类学生。

Student[] students;

students=new Student[3];

内存分配图解。！！！！！！！！！！！

在堆内存里：

将student对象的首地址附值给对象数组的第一个空间。

main()方法，由java虚拟机调用，必须是public，虚拟机在调用main方法的时候，

不需要产生任何的对象，所以声明为static，由于是java虚拟机调用不需要哟返回值，

所以为void。参数(String [] args)是一个引用类型的数组，

测试：

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

异常

数组索引越界，数组args并没有被分配空间。

args是用来接收命令行参数的。

if(args.length>0)

{

for(int i=0;i

{

System.out.println(args[i]);

}

}

不用中间变量实现数值交换

change(int x,int y)

{

x=x+y;

y=x-y;

x=x-y;

}

！！！！单纯的变量的互换不能改变他们的值。

在java中传参时，都是以传值的方式进行。

基本数据类型传递的是数据的拷贝，引用类型，传递的是引用的拷贝。

数组和对象都是引用类型，

Point由Object派生，继承了toString方法。

那么point输出格式是

getClass().getName() + '@' + Integer.toHexString(hashCode())

只有必须重载toString方法

覆盖基类当中的toString方法，返回一个类或对象的简单的描述。

class Point

{

int x,y;

public String toString()

{

return "x="+x+","+"y="+y;

}

}

改变了引用变量代表的对象当中内容，

但有时候希望他修改的是对象的拷贝，

就是不希望在函数体内修改原始的内容。

可以用对象的刻隆来实现

protected Object.clone();

需要重载并声明为public;

在派生类中实现Cloneable接口，他是一个标识接口，没有任何的抽象方法。

克隆实现

利用Object类的clone方法。

在派生类中覆盖基类的clone方法，并声明为public。

在派生类中实现Cloneable接口。

public interface Cloneable

此类实现了 Cloneable 接口，

以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。

如果在没有实现 Cloneable 接口的实例上调用 Object 的 clone 方法，

则会导致抛出 CloneNotSupportedException 异常。

Cloneable接口没有抽象方法。

Cloneable接口是一个标识接口。

是为了告诉编译器可以对对象进行克隆了。

克隆返回Object类型对象。

class Student implements Cloneable

{

String name;

int age;

Student(String name,int age)

{

this.name=name;

this.age=age;

}

public Object clone()

{

Object o=null;

try

{

o=super.clone();

}

catch(CloneNotSurpportedException e)

{

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

}

return o;

}

}

克隆方法的对比理解。

Student s1=new Student("z1","18");

Student s2=(Student)s1.clone();

//s2=s1;

s2.name="z2";

s2.age="19";

System.out.println(s1.name,s2.age);

克隆的问题

教授类

class Professor

{

String name;

int age;

Professor()

{

this.name=name;

this.age=age;

}

}

教授的名字和年龄。

Professor p=new Professor("w1",50);

Student s1=new Student("z1",18,w1);

Student s2=(Student)s1.clone();

s2.p.name="lisi"

s2.p.age=30;

System.out.println(s1.p.name,s1.p.age);

只是将引用类型的引用复制了一遍。

实际上是指向同一个教授对象。

String类型也是引用类型，并没有重写clone方法。

"lisi"是一个常量，他创建后，把"lisi"的引用附给s2.name;

克隆的是p的引用。

所以s1和s2的p的引用值都是一样的。

他们指向了同一个教授对象。是对同一块内存中的对象修改的。

得到当前时间的毫秒数

System.currentTimeMillis();

执行command line

Runtime.getRuntime().exec("calc");