java程序设计--孙鑫java无难事Lesson5《java常用包、数据类型与引用类型、函数参数传递、克隆机制》

转载 2013年03月14日 20:58:32
java程序设计--孙鑫java无难事Lesson5《java常用包、数据类型与引用类型、函数参数传递、克隆机制》
本节要点:

1.Java的常用包

2.“==”和“equals”的用法

3.基本数据类型与引用类型

4.String和StringBuffer

5.对象的克隆(clone)

详细内容:
1.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:包含一些实用工具类和数据结构类。

2.“==”和“equals”的用法--变量与对象值相等的判定方法
(1)引用类型
在Java中,boolean、byte、short、int、long、char、float、double这八种是基本数据类型,其余的都是引用类型。
(2)变量与对象值相等的判定
“==”是比较两个变量的值是否相等,“equals”是比较两个对象变量所代表的对象的内容是否相等。
测试代码:
//变量和对象值相等的判定
String str1=new String("abc");
String str2=new String("abc");
String str3=new String("abc");
if(str1==str2)
  System.out.println("str1==str2");
else
      System.out.println("str1!=str2");//str1!=str2  ==比较两个变量的值
 if(str1==str3)
       System.out.println("str1==str3");
   else
       System.out.println("str1!=str3");//str1!=str3  ==比较两个变量的值
    if(str1.equals(str2))
        System.out.println("str1==str2");//str1==str2  equals比较两个变量所引用的对象是否相等
     else
           System.out.println("str1!=str2");
3.基本数据类型与引用类型--内存模型简析

(1)基本数据类型的内存分配

内存分配过程:

a.声明引用变量,分配栈内存,引用变量值为null
b.new操作符在堆内存中分配空间返回堆内存地址

c.将堆内存地址赋给引用变量

基本数据类型内存分配如下图:

语句num=null;切断与原数组关联如下图:


(2)对象的内存分配

分配过程见下图:


(3)函数调用时的内存模型

在Java中,传参时,都是以传值的方式进行。
对于基本数据类型,传递的是数据的拷贝;对于引用类型,传递的引用的拷贝。

a.基本数据类型数据交换

基本数据类型的数据交换并不会实际交换两个数据,因为参数传递时,将会在函数中拷贝一分原数据的副本,而不是操作原数据。

//测试代码及内存模型如下图所示:


b.引用类型的数据交换

引用类型的数据交换将真正实现两个数据的交换,因为实际上是对同一对象的操作。

//测试代码及内存模型如下图所示:


4.String和StringBuffer的特性和使用
(1)String的"+"和"+=",是java中唯一被重载的操作符;在java中不允许程序员重载操作符。
字符串可以和任意类型变量相加.
(2)String是一个常量,可以理解为将一个堆中对象的地址赋给这个String对象来引用,因此String类的值将保留对象的地址引用而不能改变。为什么使用这种机制?
这种机制能够避免像语句:
String str1=new String("abc");//分配堆内存并将地址赋给引用变量str1
str1="bcd";//重新分配堆内存
这样将会造成内存浪费,因此java避免更改String中的内容,要更改其内容,可以换用StringBuffer类。在大量处理字符串的程序中使用StringBuffer类。
(3)插入、删除等其他操作  可以参见api帮助文档
//String类测试代码
//字符串使用
String str1=new String("abc");
int i=3;
float f=1.5f;
char ch='f';
boolean b=false;
//System.out.println(str1+i+f+ch+b);//ok  String类允许任意类型相加  abc31.5ffalse
StringBuffer  sb=new StringBuffer();
sb.append(str1).append(i).append(f).append(ch).append(b);
//System.out.println(sb.toString());//ok
sb.delete(4,8);//4-7error  计算索引时 包含前一个索引 但不包含后一个(结束索引)索引
sb.insert(4,"InsertTest");//插入字符串
 System.out.println(sb);//ok  自动调用toString
5.克隆(clone)机制--解决引用类型的数据保护
(1)克隆机制作用
在函数中传递参数时,传递引用类型的参数时可能导致原数据的更改,为了避免原数据的更改,采用克隆(clone)机制。克隆机制拷贝原对象的一份数据,而不对原数据直接进行操作。
(2)实现克隆机制
克隆机制的实现需要在派生类中实现Cloneable接口、覆盖基类的clone()方法,并声明为public并且派生类的clone()方法中调用super.clone()。
为什么要调用super.clone()?
在运行时刻,Object中的clone()识别出你要复制的是哪一个对象,然后为此对象分配空间,并进行对象的复制,将原始对象的内容一一复制到新对象的存储空间中。
//测试代码
class Student  implements Cloneable
{
    int age;
    String name;
    Student(String name,int age )
    {
        this.name=name;
        this.age=age;
    }
    //浅层次的拷贝
    public Object clone()
    {   
        Object o =null;
        try
        {
            o=super.clone();
        }
        catch (CloneNotSupportedException e)
        {
            System.out.println(e.toString());
        }
        return  o;
    }
}
//main函数中
//对象克隆  
Student stu1=new Student("zhangsan",18);
Student stu2=(Student)stu1.clone();//克隆后不影响原对象的数据
stu2.name="LiSi";
stu2.age=20;//不会修改stu1的数据
System.out.println("stu1.name="+stu1.name+" stu1.age="+stu1.age);
//运行结果
stu1.name=zhangsan stu1.age=18
(3)克隆机制引发的问题---深层次克隆
//测试代码
class professor
{
    int age;
    String name;
    professor(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
}
class Student  implements Cloneable
{
    int age;
    String name;
    professor p;//引用类型
    Student(String name,int age,professor p)
    {
            this.name=name;
        this.age=age;
        this.p=p;
    }
    //浅层次的拷贝
    public Object clone()
    {   
        Object o =null;
        try
        {
            o=super.clone();
        }
        catch (CloneNotSupportedException e)
        {
            System.out.println(e.toString());
        }
        return  o;
    }
}
//main函数中
professor p=new professor("WangWu",50);
Student stu1=new Student("zhangsan",18,p);
Student stu2=(Student)stu1.clone();
stu2.p.name="Zhaoer";
stu2.p.age=44;//会修改stu1.p的数据  
System.out.println("stu1.p.name="+stu1.p.name+" stu1.p.age="+stu1.p.age);
//运行结果
stu1.p.name=Zhaoer stu1.p.age=44
说明克隆的时候仍然修改了原对象stu1的数据,解决方法:让professor实现Cloneable接口和clone方法
//更改后的测试代码
class professor implements Cloneable
{
    int age;
    String name;
    professor(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    //支持克隆
    public Object clone()
    {   
        Object o =null;
        try
        {
            o=super.clone();//必须调用 复制的不是基类对象而是运行时识别复制的对象
        }
        catch (CloneNotSupportedException e)
        {
            System.out.println(e.toString());
        }
        return  o;
    }
    
}
class Student  implements Cloneable
{
    int age;
    String name;
    professor p;//引用类型
    Student(String name,int age,professor p)
    {
        this.name=name;
        this.age=age;
        this.p=p;
    }
    //深层次的拷贝
    public Object clone()
    {   
        Student s =null;
        try
        {
            s=(Student)super.clone();
        }
        catch (CloneNotSupportedException e)
        {
            System.out.println(e.toString());
        }
        s.p=(professor)s.p.clone();//复制引用类型的成员变量
        return  s;
    }
    
}
//main函数中
professor p=new professor("WangWu",50);
Student stu1=new Student("zhangsan",18,p);
Student stu2=(Student)stu1.clone();
stu2.p.name="Zhaoer";
stu2.p.age=44;//不会修改stu1.p的数据  
System.out.println("stu1.p.name="+stu1.p.name+" stu1.p.age="+stu1.p.age);
//运行结果
stu1.p.name=WangWu stu1.p.age=50
这说明没有修改stu1的数据。
6.main函数中的命令行参数
//获取命令行参数
for(int i=0;i<args.length;i++)
   System.out.println(args[i]);

相关文章推荐

java程序设计--孙鑫java无难事Lesson3《包、类和方法说明符、垃圾回收、接口》

java程序设计--孙鑫java无难事Lesson3《包、类和方法说明符、垃圾回收、接口》 本节要点: 1.包 2.类的说明符 3.方法的说明符 4.对象的销毁(垃圾内存回收的演示) ...
  • pmhlove
  • pmhlove
  • 2013年03月14日 20:56
  • 1066

java程序设计--孙鑫java无难事Lesson4《内部类、异常处理》

java程序设计--孙鑫java无难事Lesson4《内部类、异常处理》 1.内部类的特性和使用方法 概念总述: 在一个类中定义另外一个类,这个类就叫做内部类或内置类 (inner clas...
  • pmhlove
  • pmhlove
  • 2013年03月14日 20:57
  • 545

java程序设计--孙鑫java无难事Lesson11《Applet》

java程序设计--孙鑫java无难事Lesson11《Applet》 本节要点: 1.Applet编程,详细讲解Applet的生命周期,子体的设置 2.Applet从网页中获取信息,apple...
  • pmhlove
  • pmhlove
  • 2013年03月14日 21:03
  • 539

java程序设计--孙鑫java无难事Lesson6《数组相关操作、几个特殊的类、设计模式》

java程序设计--孙鑫java无难事Lesson6《数组相关操作、几个特殊的类、设计模式》 本节要点: 1.数组的相关操作 2.封装类 3.Runtime类与Process类 4.Cl...
  • pmhlove
  • pmhlove
  • 2013年03月14日 20:59
  • 1134

Java程序设计—孙鑫java无难事教程Lesson1《java技术与应用》

Java程序设计—孙鑫java无难事教程Lesson1《java技术与应用》 1.Java语言特性 简单的、面向对象的、健壮的、安全的、解释的、与平台无关的、多线程的、动态语言的。 2.Ja...
  • pmhlove
  • pmhlove
  • 2013年03月14日 20:54
  • 575

java程序设计--孙鑫java无难事Lesson10《Java图形界面编程》

java程序设计--孙鑫java无难事Lesson10《Java图形界面编程》 本节要点: 1.Java图形界面编程 2.AWT、布局管理器、事件模型, 3.JFC、Swing编程。应用J...
  • pmhlove
  • pmhlove
  • 2013年03月14日 21:03
  • 711

java程序设计--孙鑫java无难事Lesson2《位运算及面向对象程序设计》

java程序设计--孙鑫java无难事Lesson2《位运算及面向对象程序设计》 1.位运算 Java中有三个移位运算符 左移: 带符号右移:>> 无符号右移:>>>这部分内容可...
  • pmhlove
  • pmhlove
  • 2013年03月14日 20:55
  • 583

Java程序设计(Java9版):第2章 数据类型与运算符(Data types and Operators)

第2章 数据类型与运算符(Data types and Operators)I think everybody in this country should learn how to program ...

Java程序设计(Java9版):第2章 数据类型与运算符(Data types and Operators)

第2章 数据类型与运算符(Data types and Operators)I think everybody in this country should learn how to program ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:java程序设计--孙鑫java无难事Lesson5《java常用包、数据类型与引用类型、函数参数传递、克隆机制》
举报原因:
原因补充:

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