精华内容
下载资源
问答
  • Java--对象

    2018-02-03 13:13:00
    句柄和对象的关系就像电视机和遥控器的关系,我们通过遥控器来操纵电视机,但它们两个是可以脱离对方独立存在的。其外,我们平时是拿着遥控器到处走动不是电视机。 //创建句柄 String s;...

    句柄和作用域:

    虽然在Java中一切皆对象,但实际上我们不直接操纵对象,而是用句柄来操纵对象

    句柄和对象的关系就像电视机和遥控器的关系,我们通过遥控器来操纵电视机,但它们两个是可以脱离对方独立存在的。其外,我们平时是拿着遥控器到处走动而不是电视机。

    //创建句柄
    String s;
    //创建对象并和句柄链接
    s = new String("abcd");

    既然对象和句柄是可以独立存在的,那么就有作用域问题了:

    Java中主类型的作用域的有效范围和C++一样,除了下面这种情况:

    int x = 10;
    {
        int x = 0;
    }

    C++中此语法合法,即C++可以将一个变量隐藏在一个更大的作用域中;而Java中会认为重复定义报错。

    对象的作用域和主类型不同:Java中用new创建对象,它会超出作用域的范围。例如:

    {
        String s = new String("a string");
    }

    句柄s会在括号外消失,但s指向的对象不会消失(两者是相互独立的)。这种情况若在C++中,不主动释放对象空间的话可能发生内存溢出,但Java有“垃圾收集器”,会在某个时间自动回收对象空间。

    创建对象数组时,实际上是创建的句柄数组,每个句柄会初始化为一个特殊值并有自己的关键字null, 试图使用为null的句柄,则会报错。

    类由数据成员(字段)和成员函数(方法)组成。

    若某个主数据类型属于一个类成员,那么即使不明确(显式)进行初始化,也可以保证它们获得一个默认 值。

    但这种保证不适用于变量不属于类成员的情况。若变量并非一个类的字段,如在一个方法中定义一个没有初始化的变量,它会随机获得一个值而非默认值,在一些编译器中会将这种情况报错(如eclipse)。

    Java方法中参数传递是值传递,这意味着数组是传递的数组的引用,对象是传递的对象的句柄。如当把对象赋值给另一个对象或作为方法的参数传递时,都会产生别名现象,和数组一样。

    static(静态)关键字:一旦将什么东西设为static,数据或方法就不会同那个类的任何对象实例联系到一 起。我们可以通过实例出来的对象访问该静态数据或方法,更重要的是也可以直接通过类名访问。对方法来说,static 一项重要的用途就是帮助我们在不必创建对象的前提下调用那个方法,这一点是至关重要的——特别是在定义程序运行入口方法 main()的时候。

    几乎所有运算符都只能操作基本数据类型(主类型)。唯一的例外是“=”、“==”和“!=”,它们能操作所有对象。除此以外,String 类支持“+”和“+=”。

    注意:“==”和“!=”比较对象时是比较对象的句柄,如下:

    Integer l1 = new Integer(11);
    Integer l2 = new Integer(11);
    System.out.println(l1 == l2);
    System.out.println(l1 != l2);

    虽然两个对象的值完全相同,但因为是比较句柄,所以实际上输出的结果先false, 后true. 如果真的想比较对象是否相同,应该用equals()方法System.out.println(l1.equals(l2));

    但如果你创建了新类,必须重写equals()方法,因为equals()方法默认是比较句柄。大多数Java类库都实现了equals()方法用来比较对象的内容,如上述代码中的Integer类。

    组合和继承:

    继承中衍生类的初始化问题

    1. 衍生类的构造器会自动调用基础类的无参构造器进行初始化;但如果你为基础类写了带参构造器而没有写无参构造器,又没有在衍生类的构造器中显式调用基础类的带参构造器,就会出错。
    2. 衍生类的构造器中要首先设置对基础类的构造器的调用,这意味着在它之前不能出现任何东西。这种设计能够保证基础类总是能在衍生类调用它之前得到正确的初始化。

    继承中方法名的隐藏问题

    有一个方法名被“过载”使用多次,在衍生类里对那个方法名的重新定义就不会隐藏任何基础类的版本。所以无论方法在这一级还是在一个基础类中定义,过载都会生效(和C++不同)。效果如下:

    组合 or 继承?

    其实这涉及到设计模式的问题----组合模式。如果一个问题可以描述成整体和部分的关系组合模式是最合适的,比如上面的汽车类和车门、轮子、发动机类之间的关系。而继承则适用于属于关系,如上面的动物类和狗类、猫类之间的关系。

    因为组合有着极大的简洁性和灵活性,所以一般情况优先考虑利用组合。有一种情况必须使用继承--上溯造型

    上溯造型:取得 一个对象句柄,并将其作为基础类型句柄使用。

    继承的一个好处是它支持“累积开发”,允许我们引入新的代码,同时不会为现有代码造成错误。这样可将 新错误隔离到新代码里。

    final关键字:

    Java中用final关键字来声明某个东西不能被改变。对于基本数据类型,final 会将值变成一个常数;但对于对象句柄,final 会将句柄变成一个常数。进行声明时,必须将句柄初始化到一个具体的对象。而且永远不能将句柄变成指向另一个对象。然而,对象本身是可以修改的。

    final参数:方法的参数可以设置为final,这意味着在这个个方法的内部,我们不能改变参数句柄。

    final方法:第一是方法“上锁”,防止任何继承类改变它的本来含义。第二是程序执行的效率。

    只要编译器发现一个final 方法调用,就会忽略为执行方法调用机制而采取的常规代码插入方法(将自变量压入堆栈;跳至方法代码并执行它;跳回来;清除堆栈自变量;最后对返回值进行处理)。相反,它会用方法主体内实际代码的一个副本来替换方法调用。这 样做可避免方法调用时的系统开销。当然,若方法体积太大,那么程序也会变得雍肿,可能受到到不到嵌入代码所带来的任何性能提升。Java 编译器能自动侦测这些情况,并颇为“明智”地决定是否嵌入一个 final 方法。然而,最好还是不要完全相信编译器能正确地作出所 有判断。通常,只有在方法的代码量非常少,或者想明确禁止方法被覆盖的时候,才应考虑将一个方法设为 final。 类内所有private 方法都自动成为final。

    final类:将类定义成 final 后,结果只是禁止进行继承——没有更多的限制。然而,由于它禁止了继承,所以一个 final 类中的所有方法都默认为 final。

    展开全文
  • 对象是不能脱离类存在的。类是对象共同拥有的属性的描述,由对象归纳成类,对象是类的具体体现。如汽车是一个类,具体到某个人的车就是对象。 在C#中,所有的东西都可以看作对象。把一个东西看成对象,...

    类和对象是密不可分,有类就有对象。有对象就有类,世界万物都可以看作对象。用面向对象的思想解决问题,就要把一切都看成对象。

    对象是不能脱离类存在的。类是对象共同拥有的属性的描述,由对象归纳成类,对象是类的具体体现。如汽车是一个类,而具体到某个人的车就是对象。

    在C#中,所有的东西都可以看作对象。把一个东西看成对象,我们就可以孤立的去审查它的性质,它的行为,进而研究和其他对象的关系。同样,在程序中使用对象的概念,就让我们把一个程序看成是很多对象相互作用的结果。

    对象必须建立在类的基础上,声明一下对象也就是类的实例化过程。对象是类的具体化的体现。

    我们创建一个教师类

    classs Teacher {
       public string Name; // 老师姓名
       public uint Age; // 老师年龄
       public string Phone; // 老师电话
       public string Address; // 老师通讯地址
    }

    注意:类的成员变量访问修饰符都使用了public,在其他类中可以访问。

    声明对象的语法如下:

    类名 对象名=new 类名();

    访问类的成员变量的语法如下:

    对象名.变量名

    下面声明一个Teacher对象,即实例化类Teacher,代码如下:

    Teacher t=new Teacher();

    t.Name="小刘";

    我们通过new操作符创建类的对象,也叫做类的实例化,然后使用“.”来操作对象的属性。类的任何成员和成员方法也都是通过点号来调用的。

    using System;
    class Teacher {
       public string Name; // 老师姓名
       public uint Age; // 老师年龄
       public string Phone; // 老师电话
       public string Address; // 老师通讯地址
    }
    class Test{
       public static void Main()    {
          Teacher t=new Teacher(); // 实例化Teacher类
          t.Name="小刘";
          t.Age=35;
          t.Phone="13381335310";
          t.Address="北京大学";
          Console.WriteLine("该老师姓名={0},年龄={1},电话={2},通讯地址={3}",
                 t.Name,t.Age,t.Phone,t.Address);
       }
    }

    展开全文
  • 类和对象是密不可分有类就有对象对象就有类世界万物都可以看作对象用面向对象的思想解决问题就要把一切都看成对象 对象是不能脱离类存在的类是对象共同拥有的属性的描述由对象归纳成类对象是类的具体体现如汽车是...
  • 复合对象

    2014-09-26 18:45:27
    复合对象:是指对象的一个或者多个属性引用了其他对象。 组合与聚合: ...组合:车子包括= 车身+车轮+发动机 ...聚合:例如在家庭关系中,将男人...部分可以脱离整体而存在 例如 摄影协会和会员的关系

    复合对象:是指对象的一个或者多个属性引用了其他对象。


    组合与聚合:


    组合:车子类包括= 车身类+车轮类+发动机类

    聚合:例如在家庭关系中,将男人、女人和孩子组合在一起建立起一个聚合关系称作“家庭”  

    组合是更强形式的聚合 
    其中整体负责部分 
    而每个部分对象也仅与一个整体对象联系


    聚合是同质的
    部分可以脱离整体而存在
    例如 摄影协会和会员的关系  


    区分: 1、判断“部分是整体的一部分吗”

    2、判断整体是否管理部分

    3、对部分发生兴趣

    展开全文
  • 一、序列化的含义和意义:序列化机制使得对象可以脱离程序的运行独立存在。对象的序列化指将一个Java对象写入IO流中,与此对应的反是,对象的反序列化则指从IO流中恢复该Java对象。如果需要需要让某个对象支持序列...

    Java对象序列化

    首先介绍一下对象序列化的目标:对象序列化的目标是将对象保存到磁盘中,或允许在网络中直接传输对象。

    一、序列化的含义和意义:

    序列化机制使得对象可以脱离程序的运行而独立存在。

    对象的序列化指将一个Java对象写入IO流中,与此对应的反是,对象的反序列化则指从IO流中恢复该Java对象。

    如果需要需要让某个对象支持序列化机制,则必须让它的类是可序列化的(serializable)。为了让某个类是可序列化的,该类必须实现如下两个接口之一:

    Serializable

    Externalizable

    Serializable接口是一个标记接口,实现该接口无需实现任何方法,它只是表明该类的实例是可序列化的。

    所有需要保存到磁盘里的对象的类都应该可序列化。

    二、使用对象流实现序列化(使用Serializable接口)

    使用 Serializable 来实现序列化非常简单,主要让目标类实现 Serializable 标记接口即可,无须实现任何方法。

    一旦某个类实现了 Serializable 接口,该类的对象就是可序列化的,程序可以通过如下两个步骤来序列化该对象。

    1.创建一个 ObjectOutputStream,这个输出流是一个处理流,所以必须建立在其他节点流的基础上。如下代码所示。

    //创建 ObjectOutputStream 输出流

    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("file.txt));

    2.调用 ObjectOutputStream 对象的writeObject()方法输出可序列化对象。如下代码所示。

    //将一个对象输出到输出流中

    oos.writeObject(text);

    如果希望从二进制流中恢复 Java对象,则需要使用反序列化。反序列化的步骤如下.

    1.创建一个 ObjectInputStream 输入流,这个输入流是一个处理流,所以必须建立在其他节点流的基础之上。如下代码所示。

    //创建一个ObjectInputStream()输入流

    ObjectInputStream ois = new ObjectInputStream(new FileInputstream("file.txt"));

    2.调用 ObjectInputStream 对象的readObject()方法读取流中的对象,该方法返回一个 Object 类型的 Java 对象,如果程序知道该 Java 对象的类型,则可以将该对象强制类型转换成其真实的类型。如下代码所示。

    //从输入流中读取一个 Java 对象,并将起强制类型转换为 Test 类

    Test t=(Test) ois.readObject();

    三、实例

    下面程序定义了一个 Student 类,这个 Student 就是一个普通的 Java 类,只是实现了 Serializable 接口,该接口标识该类的对象是可序列化的。

    public class Student implements java.io.Serializable {

    /**

    *

    */

    private static final long serialVersionUID = 1L;

    private int num;

    private String name;

    public Student(int num, String name) {

    this.num = num;

    this.name = name;

    }

    public int getNum() {

    return num;

    }

    public void setNum(int num) {

    this.num = num;

    }

    public String getName() {

    return name;

    }

    public void setName(String name) {

    this.name = name;

    }

    }

    下面程序使用 ObjectOutputStream 将一个 Student 对象写入磁盘文件

    public class WriteObjcect {

    public static void main(String[] args) {

    try {

    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Student.txt"));

    Student stu = new Student(1,"吴彦祖");

    oos.writeObject(stu);

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    }

    上面程序中的第四行代码创建了一个 ObjectOutputStream 输出流,这个 ObjectOutputStream 输出流建立在一个文件输出流的基础上;程序第六行代码使用 writeObject() 方法将一个 Student 对象写入输出流。运行上面程序,将会看到生成了一个 Student.txt 文件,该文件的内容就是 Student 对象。

    下面程序示范了从刚刚生成的 Student.txt 文件中读取 Student 对象的步骤

    public class ReadObject {

    public static void main(String[] args) {

    try {

    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("Student.txt"));

    Student stu = (Student) ois.readObject();

    System.Out.println("名字为:" + p.getname() + "\n年龄为:" + p.getnum());

    } catch(Exception e) {

    e.printStackTrace();

    }

    }

    }

    上面程序第四行代码将一个文件输入流包装成 ObjectInputStream 输入流,第五行代码使用 readObject() 读取了文件中的 Java 对象,这就完成了反序列化过程。

    四、注意

    反序列化读取的仅仅是 Java 对象的数据,而不是 Java 类,因此采用反序列化恢复 Java 对象时,必须提供该 Java 对象所属的 class 文件,否则将会引发 ClassNotFoundException 异常。

    Student 类只有一个有参的构造器,没有无参的构造器,而且该构造器内有一个普通的打印语句。当反序列化 Java 对象时,并没有看到程序调用该构造器,这表明反序列化机制无须通过构造器来初始化 Java 对象。

    如果使用序列化机制向文件中写入了多个 Java 对象,使用反序列化机制恢复对象时必须按实际写入的顺序读取。

    当一个可序列化对象有多个父类时(包括直接父类和间接父类),这些父类要么有无参的构造器,要么也是可序列化的——否则反序列化时将抛出 InvalidClassException 异常。如果父类是不可序列化的,只是带有无参构造器,则该父类中定义的成员变量值不会序列化到二进制流中。

    **end**

    展开全文
  • Java对象序列化

    2020-07-01 16:25:28
    所以序列化使Java对象可以脱离程序独立存在。 Java实现可序列化的要求是,实现下面的两个接口之一: Serializable Externalizable 一、使用对象流实现序列化 两个步骤实现序列化: 创建...
  • 对象序列化

    2018-11-16 18:17:29
    序列化机制使得对象可以脱离程序的运行独立存在。 序列化(Serialize)是指将Java对象写入IO流中,反序列化(Deserialize)则指从IO流中恢复该Java对象。 为了让某个是可序列化的,该必须实现如下两个接口之一:...
  • 将Java对象写入文件中

    万次阅读 2018-06-05 00:01:39
    序列化机制使得对象可以脱离程序的运行独立存在。 对象的序列化指将一个Java对象写入IO流中,与此对应的反是,对象的反序列化则指从IO流中恢复该Java对象。 如果需要需要让某个对象支持序列化机制,则必须让它的...
  • 对象流:存储对象的流* 对象的序列化:指将一个JAVA对象写入IO流* 对象的反序列化:指将一个IO流回复成JAVA对象* 序列化的作用:序列化机制使得对象可以脱离程序的运行独立存在* 要求:如果需要让某个对象可以支持...
  • 静态内部是外部的静态成员,不依赖于外部对象而存在,因此在外部外面创建静内部类对象时不需要首先创建外部对象 静态内部可以称为静态嵌套或顶级嵌套。 静态内部与外部类对象之间不存在着对...
  • 序列化机制使得对象可以脱离程序的运行独立存在。 对象的序列化(Serialize)指将一个Java对象写入IO流中,与此对应的是,对象的反序列化(Deserialize)则指从IO流中恢复该Java对象。如果需要让某个对象可以支持...
  • 在我们的很多时候,可能会用到静态变量,如统计随时可...1:首先,经过测试,静态变量是可以脱离对象而存在的,准确的说,静态变量是属于的。 2:在内有self和对象取值两种方式,在外,只有对象取值这一种方式。
  • 的组合与聚合区别

    2014-01-06 10:16:32
    学习uml总是不好分清聚合与组合的关系,对聚合与组合的了解:聚合:表示两个对象之间是整体和部分的弱关系,部分的生命...如人和眼睛的关系:不过,如果你要说,眼睛可以移植,是不是说可以脱离而存在,它们就不是
  • 1. 关联 一个作为另外一个的变量;... 表示整体和部分的关系,成员是整体的一部分,但是成员可以脱离整体单独存在。在uml中,聚合关系用带空心菱形的直线表示; 3. 组合 组合(Composition)关系也表示...
  • 空指针异常(NullPointException,简称 NPE)可以说是所有 Java 程序员都遇到过的一个异常,虽然 Java 从设计之初就力图让程序员脱离指针的苦海,但是指针确实是实际存在的, Java 设计者也只能是让...
  • 聚合与组合

    2015-08-10 20:23:44
    聚合:表示两个对象之间是整体和部分的弱关系,成员对象可以脱离整体对象而独立存在。has-a关系 组合:表示两个对象之间是整体和部分的强关系,部分的生命周期不能超越整体,或者说不能脱离整体而存在。部分与整体...
  • 序列化机制使得java对象可以脱离程序独立存在。 使用场景 把对象进行网络传输 把对象保存到磁盘 可序列化的 如果父类是可序列化的,那么子类可以序列化 如果的成员是可序列化的,那么可以序列化 序列化...
  • 什么是迭代器模式 ...成员对象是整体对象的一部分,但成员对象可以脱离整体对象而存在。就像学校与老师,学校包括老师,但即使学校停办了老师依然存在。 这样类比,聚合就像是一个集合,聚合对象就像是
  • java 序列化机制深度解析

    千次阅读 2016-06-17 11:02:13
    序列化机制允许将实现序列化的Java对象转换为字节序列,这些字节序列可以被保存在磁盘上或通过网络传输,以备以后重新恢复原来的对象,序列化机制使得对象可以脱离程序的运行独立存在 可序列化的包括:实现了...
  • java 序列化

    2017-08-09 20:14:11
    序列化机制允许将实现序列化的Java对象转换为字节序列,字节序列可以保存在磁盘,或通过网络传输,以备以后重新恢复原来的对象,序列化机制使得对象可以脱离程序的运行独立存在。  对象的序列化指讲一个Java对象...
  • 学习笔记2019/4/2

    2019-04-02 21:19:23
    方法不能脱离类而存在。 使用static修饰的方法或者变量属于这与这个类,可以使用对象去调用,但是结果和使用类调用是一样的。 在java里面参数的传递机制只有一种,值传递。也就是传递参数的副本,但是参数本身不受...
  • 引言 Scala中的函数是Java中...Java中的方法是绝对不可能脱离类对象独立存在的。 Scala是一门既面向对象,又面向过程的语言。因此在Scala中有非常好的面向对象的特性,可以使用Scala来基于面向对象的思想开发大...
  • 引言 Scala中的函数是Java中...Java中的方法是绝对不可能脱离类对象独立存在的。 Scala是一门既面向对象,又面向过程的语言。因此在Scala中有非常好的面向对象的特性,可以使用Scala来基于面向对象的思想开发大...
  • Scala 函数式编程

    2019-10-23 15:43:18
    引言 Scala中的函数是Java中...Java中的方法是绝对不可能脱离类对象独立存在的。 Scala是一门既面向对象,又面向过程的语言。因此在Scala中有非常好的面向对象的特性,可以使用Scala来基于面向对象的思想开发大...
  • 引言 Scala中的函数是Java中...Java中的方法是绝对不可能脱离类对象独立存在的。 Scala是一门既面向对象,又面向过程的语言。因此在Scala中有非常好的面向对象的特性,可以使用Scala来基于面向对象的思想开发大...

空空如也

空空如也

1 2 3
收藏数 58
精华内容 23
关键字:

对象可以脱离类而存在