精华内容
下载资源
问答
  • C++定义类和对象的两种方式–对比Java搞了一段时间java再回来搞C++,在有些地方会偶尔不太适应,例如,这里要说的对象的声明,Java和C++就有很大的不同。 比如说这里有一个类: //C++方式定义一个class class Son :...

    C++定义类和对象的两种方式–对比Java

    搞了一段时间java再回来搞C++,在有些地方会偶尔不太适应,例如,这里要说的对象的声明,Java和C++就有很大的不同。
    比如说这里有一个类:

    //C++方式定义一个class
    class Son :public Dad 
    {
    private:
        const int count;
    public:
        Son()
        {
            cout<<"Son's constructor"<<endl;
        }
        void sayName()
        {
            cout<<"I am Son"<<endl;
        }
        ~Son()
        {
            cout<<"Son's destructor"<<endl;
        }
    };
    
    //java方式定义一个class
    class Son extends Dad
    {
        private final int count;
    
        public Son(){}
        public void sayName(){}
    }
    

    可以发现,在对class的定义上,C++和Java就有很多差别。这里举例几个:

    1. class声明最后,C++需要在大括号后面添加分号”;”,而java不用

    2. 继承的表达,C++使用 冒号+继承方式 “:public”,Java使用“extends”

    3. 方法和属性的访问控制关键字,C++是一次性使用,比如上面使用”public:”然后在后面跟所有声明为public的方法或属性;而Java则需要在每一个方法或属性前面都添加访问控制关键字

    4. 构造函数C++和Java都可以有,但是只有C++可以创建析构函数,Java有垃圾回收机制,所以并不需要析构函数,这是Java对C++的改进之一

    5. Java使用final代替了C++里面的const,当然static(静态)的用法还是大家一致的

    应该还有别的差别,这里暂时就列这么几点了。

    然后再来看对象的声明方式上,C++和Java的差别。
    我们首先先来看C++的,对象的声明有两种方式:

    1. Son obj; //变量式声明  
    
    2. Son *obj; //指针式声明
    

    结合实例代码来看这两种声明方式会带来什么差异:

    #include <iostream>
    using namespace std;
    
    class Son
    {
    public:
        Son()
        {
            cout<<"Son's constructor"<<endl;
        }
        void sayName()
        {
            cout<<"I am Son"<<endl;
        }
        ~Son()
        {
            cout<<"Son's destructor"<<endl;
        }
    };
    int main()
    {
        cout<<"Way 1--Son obj1:"<<endl;
        Son obj1;
        obj1.sayName();
    
        return 0;
    }
    

    输出结果:

    Way 1--Son obj1:
    Son's constructor
    I am Son
    Son's destructor
    
    --------------------------------
    Process exited after 0.02231 seconds with return value 0
    请按任意键继续. . .
    

            这是C++的声明对象的方式,如果是习惯了很久的Java而把C++忘得差不多了的话,看到这里的输出会觉得略惊诧。
            没错!在Java中”Son obj1;”这样的对象声明方式并不会给对象分配空间,仅仅是声明了一个对象的引用,分配的空间只是这个引用的空间,实际的类对象的空间并没有被创建(初始化)。
            然而在C++中,会发现这里该种创建对象的方式一样会调用构造函数和析构函数!也就是说,C++是支持这种方式声明对象并为其分配空间的。
            所以在对象这块,我感觉Java对于空间分配相比C++更加严格,并且我们知道在java中如果你并没有给对象分配空间(例如只是上面这样声明了一个对象:”Son Obj;”但并没有使用new等方式分配内存),那么你想直接去调该对象的成员方法,是会发现编译直接就报错,或者即便编译通过了(例如Java智能卡applet平台的编程编译器就没提示错误),然而运行的时候会发现奇怪的运行结果,然后debug的时候艰难地发现对该对象成员方法的调用根本就跳不进去!因为前面没有用new等方法给对象分配内存空间,没有分配内存,何谈函数调用?

    //Java创建未初始化的对象
    public class Son {
    
    public Son(){}
    
    public void sayName()
    {
        System.out.println("I am Son");
    }
    
    public static void main(String[] args) {
        Son obj;
        obj.sayName();
    }
    }
    

    编译器会直接提示如下错误(对象/变量未初始化就调用其成员方法报错):

    The local variable obj may not have been initialized
    

            所以说我觉得Java对内存空间管理比C++严格。程序分配内存Java就有严格的管理,例如要求你要用new关键字,然后内存的回收Java的垃圾回收机制它又帮你做了,所以在java里面在内存管理这块就没C++那么费心也没那么容易出错,因为它从语言的设计上就对程序员屏蔽了容易出错或者说容易导致不规范编程的那几块东西。而在C++,你需要考虑和惦记着的东西就多了很多,一旦编程不慎,就容易导致错误。
            上面是C++的第一种创建对象的方式,下面介绍第二种也就是使用指针的方式。当然Java里面已经对程序员屏蔽了指针,所以不存在指针方式创建对象。

    cout<<"Way 2--Son *obj2:"<<endl;
    Son *obj2 = new Son();
    obj2->sayName();
    delete obj2;
    

    程序输出结果:

    Way 2--Son *obj2:
    Son's constructor
    I am Son
    Son's destructor
    
    --------------------------------
    Process exited after 0.01643 seconds with return value 0
    请按任意键继续. . .
    

    特别注意,这种用new的方式创建对象时,需要用指针来接收new的返回值,而不能是:

    Son obj2 = new Son(); 
    //编译器会报错说[Error] conversion from 'Son*' to non-scalar type 'Son' requested
    

    另外一个需要特别注意的是,这种创建对象的方式之后,对成员方法的调用只能使用箭头:obj->sayName();而不能是obj.sayName();否则编译报错提示叫你替换成  ->  。而上面第一种创建对象的方法后面则只能用obj.sayName();调用方法,用箭头则会报错。

            接下来,就着这第二种创建对象的方式,我们对代码做一些调整,看看效果如何:

    cout<<"Way 2--Son *obj2:"<<endl;
    Son *obj2;
    obj2->sayName();
    delete obj2;
    

    你猜这样的程序效果会怎样?
    答案是编译通过并且运行正常,输出结果为:

    Way 2--Son *obj2:
    I am Son
    Son's destructor
    
    --------------------------------
    Process exited after 0.01833 seconds with return value 0
    请按任意键继续. . .
    

    这里虽然没有使用new关键字,但是程序依然可以调用对象的成员方法,同时也可以用delete调用析构函数。然而构造函数并没有被调用到。来看个更明显的例子:

    #include <iostream>
    using namespace std;
    
    class Son
    {
    private:
        int i; 
    public:
        Son()
        {
            i = 6;
            cout<<"Son's constructor "<<i<<endl;
        }
        void sayName()
        {
            cout<<"I am Son"<<endl;
        }
        ~Son()
        {
            cout<<"Son's destructor"<<endl;
        }
        void setI(int a) 
        {
            i = a;
        }
        int getI()
        {
            return i;
        }
    };
    int main()
    {
    //  cout<<"Way 1--Son obj1:"<<endl;
    //    Son obj1;
    //    obj1.sayName();
        cout<<"Way 2--Son *obj2:"<<endl;
        Son *obj2;
        int r = obj2->getI();
        cout<<r<<endl;
    
        obj2->setI(3);
        r = obj2->getI();
        cout<<r<<endl;
    
        return 0;
    }
    

    程序在gcc下编译通过,运行输出为:

    Way 2--Son *obj2:
    1528349827
    3
    
    --------------------------------
    Process exited after 0.01925 seconds with return value 0
    请按任意键继续. . .
    

    这证明程序确实没有调用到Son的构造函数(第一遍cout输出的i的初值为一个奇葩的数,并且每次运行都是固定的这个数),但是Son *obj;这般定义的对象一样可以直接调用其成员方法。并且运行结果最后并没有自动调用析构函数(没有析构函数的输出)。可见该对象的作用域不仅限于main函数,证明它是在堆空间存储。如果运用上面说的java中对象分配空间的严格要求,这里就会显得很奇怪了,程序并没有使用new关键字,而是直接声明一个Son类型的指针,然而它却可以操作成员属性、调用成员方法。问了公司一个编程方面挺有经验的一个前辈,也说不应该编译通过,应该是堆栈溢出,因为并没有给该对象分配空间就去操作它的方法了。但是在Dev-gcc的编译环境下却可以正常地编译通过并正常运行,所以这就很难解释了,究竟是编译器的问题,还是其实C++是支持这种声明和使用方式的,有待自己后面发掘答案。

            总结下本篇讲的两种C++定义对象的两种方式:
    1.

    Son obj;
    obj.method();
    

    2.

    Son *obj = new Son();
    obj->method();
    

    最后这里有两个别人的博客可供参考:
    http://c.biancheng.net/cpp/biancheng/view/185.html
    http://blog.csdn.net/youketudou/article/details/6624145

    展开全文
  • java通过反射创建对象的两种方式

    千次阅读 2019-03-07 15:44:05
    java中,通过反射创建对象有两种方式 使用Class对象的newInstance()方法来创建对象; 具体步骤是 1、获取类的Class对象(有三种方式可以获取,可以自行百度一下) 2、通过调用所获取到的Class对象的newInstance...

    我个人觉得我自己是个比较粗心的人,所以各位大佬发现有什么不对的地方还请留言告知
    在java中,通过反射创建对象有两种方式

    1. 使用Class对象的newInstance()方法来创建对象;
      具体步骤是:
      1、获取类的Class对象(有三种方式可以获取,可以自行百度一下)
      2、通过调用所获取到的Class对象的newInstance()来获得对象,该方法会返回一个Object类型的对象,所以还需要强转一下;
      举个例子:
      新建一个Hog,里面定义一个方法getName()输出一句话,可以看到运行之后控制台输出了青青草原四个字,
    package Lin;
    
    public class Pig {
        public static void main(String[] args) throws IllegalAccessException, InstantiationException {
            //通过类.class的方式获取一个该类的Class实例
            Class hogClass = Hog.class;
            //通过调用newInstance()方法获取一个Hog的实例, 该方法会返回一个Object类型的对象并且会抛出两个异常,
            Hog hog = (Hog) hogClass.newInstance();
            hog.getName();
        }
    }
    class Hog {
        public void getName() {
            System.out.println("青青草原");
        }
    }
    

    在这里插入图片描述

    把上面的代码再修改一下
    修改后的代码在Hog类构造函数中添加了一句代码,输出一句话,然后运行代码,可以发现构造函数被调用了,说明在使用Class类的newInstance()方法获得一个类的实例时,依然会调用他的(默认)构造函数;

    package Lin;
    
    public class Pig {
        public static void main(String[] args) throws IllegalAccessException, InstantiationException {
            //通过类.class的方式获取一个该类的Class实例
            Class hogClass = Hog.class;
            //通过调用newInstance()方法获取一个Hog的实例, 该方法会返回一个Object类型的对象并且会抛出两个异常,
            Hog hog = (Hog) hogClass.newInstance();
            hog.getName();
        }
    }
    class Hog {
        public Hog() {
            System.out.println("无参构造函数");
        }
        public void getName() {
            System.out.println("青青草原");
        }
    }
    

    在这里插入图片描述

    1. 通过Constructor类的newInstance()方法获取
      具体步骤是
      1、获取一个类的一个Class实例;
      2、调用Class中的getConstructor()方法获得一个Constructor对象,
      3、调用Constructor的newInstance()方法获得一个类的实例;

      再举个例子,把上面的代码稍微改一下:
      Hog类中的代码不变,在主方法中通过getConstructor()方法获得一个Constructor类的实例,然后通过Constructor的newInstance()方法获得一个类的实例;

    getConstructor(Class<?>… parameterTypes)方法中可以传递Class类型的参数(不知到Class…的可以把他理解成参数是Class类型的数组),通过传递的参数来获得Class对象所包含的类的指定的public构造方法(就是找指定的构造方法,因为一个类可以有好多个构造方法,当你的一个构造方法为public Hog(int a) 时, 那就可以传递int.class进去)想知道的就查相关api吧,

    package Lin;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.InvocationTargetException;
    
    public class Pig {
        public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
            //通过类.class的方式获取一个该类的Class实例
            Class hogClass = Hog.class;
            //调用Class类的getConstructor()获得一个指定的构造器(参数为空则获得默认的构造器)对象   注意 获得的构造器得是被public修饰的
            Constructor constructor = (Constructor) hogClass.getConstructor();
            //调用Constructor的newInstance()方法获取一个Hog实例(注意要强转)
            Hog hog = (Hog) constructor.newInstance();
            hog.getName();
        }
    }
    class Hog {
        public Hog() {
            System.out.println("无参构造函数");
        }
        public void getName() {
            System.out.println("青青草原");
        }
    }
    

    运行截图:
    在这里插入图片描述
    将上面的代码再进行修改一下
    1.在Hog类中定义一个带参的构造函数,形参为String类型
    2.在主方法中调用Class的getConstructor()方法并传递String.class进去(告诉方法我要找到一个参数 是String类型的构造函数)
    3.调用Constructor的newInstance()方法并传递一个String类型的字符串进去(可以理解成就是传递构造函数的参数进去)
    运行之后可以看到带参数的构造函数被调用了;

    package Lin;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.InvocationTargetException;
    
    public class Pig {
        public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
            //通过类.class的方式获取一个该类的Class实例
            Class hogClass = Hog.class;
            //调用Class类的getConstructor()获得一个参数为String类型的构造器对象
            Constructor constructor = (Constructor) hogClass.getConstructor(String.class);
            //调用Constructor的newInstance()方法获取一个Hog实例(传递一个String类型的参数)
            Hog hog = (Hog) constructor.newInstance("我是Constructor类调用的");
            hog.getName();
        }
    }
    
    class Hog {
        public Hog() {
            System.out.println("无参构造函数");
        }
    
        public Hog(String message) {
            System.out.println(message);
        }
    
        public void getName() {
            System.out.println("青青草原");
        }
    }
    

    在这里插入图片描述
    两种方法的区别
    第一种方法、通过Class的newInstance()方法只能使用默认的构造方法,换句话说就是使用此方法是不能通过带参的构造函数来生成一个类的实例;

    第二种方法、通过Constructor的newInstance()方法可以使用默认的构造方法,也可以使用带参的构造方法来生成一个类的实例

    在只有一个默认的构造函数(或不带参数的构造函数)时,使用第一种方法比较方便,如果要使用类中的其他构造方法那只能使用第二种方法了。

    展开全文
  • Map是HashMap父类,第一声明方式是:父类引用指向子类的对象,是多态表现形式;第二是:使用本身引用。举个例子:第一声明方式是实现了多态,多态后就可以写出一段所有子类都通用代码,当添加新...

    Map是HashMap的父类,第一种声明方式是:父类的引用指向子类的对象,是多态的一种表现形式;第二种是:使用本身引用。举个例子:

    第一种声明方式是实现了多态,多态后就可以写出一段所有子类都通用的代码,当添加新的子类时,这段代码是不需要修改的。

    比方说:父类Animal,子类Cat,Dog

    //如果使用第2行,当改用Dog的时候,那么第3行也需要改变

    1 Animal a = new Cat();

    2 //Cat a = new Cat();

    3 a.someMethod();

    父类的引用指向子类的对象的好处:多态、动态链接,向上转型。

    方法的重写、重载与动态连接构成多态性。Java之所以引入多态的概念,原因之一是它在类的继承问题上和C++不同,后者允许多继承,这确实给其带来的非常强大的功能,但是复杂的继承关系也给C++开发者带来了更大的麻烦,为了规避风险,Java只允许单继承,派生类与基类间有IS-A的关系(即“猫”is a “动物”)。这样做虽然保证了继承关系的简单明了,但是势必在功能上有很大的限制,所以,Java引入了多态性的概念以弥补这点的不足,此外,抽象类和接口也是解决单继承规定限制的重要手段。同时,多态也是面向对象编程的精髓所在。

    理解多态,首先要知道“向上转型”。

    我定义了一个子类Cat,它继承了Animal类,那么后者就是前者是父类。我可以通过

    Cat c = new Cat();

    实例化一个Cat的对象,这个不难理解。但当我这样定义时:

    Animal a = new Cat();

    这代表什么意思呢?

    很简单,它表示我定义了一个Animal类型的引用,指向新建的Cat类型的对象。由于Cat是继承自它的父类Animal,所以Animal类型的引用是可以指向Cat类型的对象的。这就是“向上转型”。

    那么这样做有什么意义呢?因为子类是对父类的一个改进和扩充,所以一般子类在功能上较父类更强大,属性较父类更独特, 定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能,又可以抽取父类的共性。 所以,父类类型的引用可以调用父类中定义的所有属性和方法,而对于子类中定义而父类中没有的方法,父类引用是无法调用的;

    那什么是动态链接呢?当父类中的一个方法只有在父类中定义而在子类中没有重写的情况下,才可以被父类类型的引用调用; 对于父类中定义的方法,如果子类中重写了该方法,那么父类类型的引用将会调用子类中的这个方法,这就是动态连接。

    展开全文
  • 1、通过实现Runnable...定义一个类实现Runnable接口,重写接口中run()方法。在run()方法中加入具体任务代码或处理逻辑。 (2).创建Runnable接口实现类的对象。 (3).创建一个Thread类的对象,需要封装前面Runnabl

    http://blog.csdn.net/touch_2011/article/details/6891026

    1、通过实现Runnable接口线程创建

    (1).定义一个类实现Runnable接口,重写接口中的run()方法。在run()方法中加入具体的任务代码或处理逻辑。

    (2).创建Runnable接口实现类的对象。

    (3).创建一个Thread类的对象,需要封装前面Runnable接口实现类的对象。(接口可以实现多继承)

    (4).调用Thread对象的start()方法,启动线程

    示例代码:

    1. <span style="font-size:16px;">package demo.thread;  
    2.   
    3. public class TreadDemo1 implements Runnable {  
    4.     private int countDown = 10;  
    5.     @Override  
    6.     // 在run方法中定义任务  
    7.     public void run() {  
    8.         while (countDown-- > 0) {  
    9.             System.out.println("#" + Thread.currentThread().getName() + "("  
    10.                     + countDown + ")");  
    11.         }  
    12.     }  
    13.   
    14.     public static void main(String[] args) {  
    15.         // Runnable中run方法是一个空方法,并不会产生任何线程行为,必须显式地将一个任务附着到线程上  
    16.         TreadDemo1 tt=new TreadDemo1();  
    17.         new Thread(tt).start();  
    18.         new Thread(tt).start();  
    19.         System.out.println("倒计时:");  
    20.     }  
    21. }  
    22. </span> 
    运行结果:

    倒计时:
    #Thread-0(8)
    #Thread-0(7)
    #Thread-0(6)
    #Thread-1(5)
    #Thread-1(4)
    #Thread-0(4)
    #Thread-1(3)
    #Thread-1(1)
    #Thread-1(0)
    #Thread-0(2)

    2、通过继承Thread类创建线程

    (1).首先定义一个类去继承Thread父类,重写父类中的run()方法。在run()方法中加入具体的任务代码或处理逻辑。
    (2).直接创建一个ThreadDemo2类的对象,也可以利用多态性,变量声明为父类的类型。

    (3).调用start方法,线程t启动,隐含的调用run()方法。

    示例代码:

    1. <span style="font-size:16px;">package demo.thread;  
    2.   
    3. public class ThreadDemo2 extends Thread {  
    4.     private int countDown = 10;  
    5.   
    6.     @Override  
    7.     // 在run方法中定义任务  
    8.     public void run() {  
    9.         while (countDown-- > 0) {  
    10.             System.out.println("#" + this.getName() + "(" + countDown + ")");  
    11.         }  
    12.     }  
    13.   
    14.     public static void main(String[] args) {  
    15.         new ThreadDemo2().start();  
    16.         new ThreadDemo2().start();  
    17.         // 由于start方法迅速返回,所以main线程可以执行其他的操作,此时有两个独立的线程在并发运行  
    18.         System.out.println("倒计时:");  
    19.     }  
    20. }  
    21. </span>  


    运行结果:

    倒计时:
    #Thread-0(9)
    #Thread-0(8)
    #Thread-0(7)
    #Thread-1(9)
    #Thread-0(6)
    #Thread-1(8)
    #Thread-0(5)
    #Thread-1(7)
    #Thread-0(4)
    #Thread-1(6)
    #Thread-0(3)
    #Thread-0(2)
    #Thread-0(1)
    #Thread-0(0)
    #Thread-1(5)
    #Thread-1(4)
    #Thread-1(3)
    #Thread-1(2)
    #Thread-1(1)
    #Thread-1(0)

    采用继承Thread类方式:
    (1)优点:编写简单,如果需要访问当前线程,无需使用Thread.currentThread()方法,直接使用this,即可获得当前线程。
    (2)缺点:因为线程类已经继承了Thread类,所以不能再继承其他的父类。
    采用实现Runnable接口方式:
    (1)优点:线程类只是实现了Runable接口,还可以继承其他的类。在这种方式下,可以多个线程共享同一个目标对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU代码和数据分开,形成清晰的模型,较好地体现了面向对象的思想。
    (2)缺点:编程稍微复杂,如果需要访问当前线程,必须使用Thread.currentThread()方法。

    展开全文
  • java对象的访问定位方式

    千次阅读 2015-07-10 16:17:34
    由于reference类型在java虚拟机规范中只规定了一个对象的引用,并没有定义这个这个引用应该通过那种方式去定位、访问java堆中的具体对象实例,所以一般的访问方式也是取决与java虚拟机的类型。目前主流的访问方式有...
  • protobuffer的前世今生(四)——在Java的两种使用方式首先用pb格式定义一个proto文件编译运行运用创建一个实例假如你有一个自定义的Album对象实例化AlbumProtos.Album将对象写成二进制(字节数组)的形式从二进制...
  • Java对Elasticsearch操作都是使用Client对象...Java操作ESClient有两种:TransportClient和Rest Client。但是Elasticsearch 7.0中开始弃用TransportClient,在8.0中完全删除它。故在实际使用过程中建议使用Jav...
  • java对象在访问的时候,...目前主流的访问方式有通过句柄和直接指针两种方式。 1.句柄 使用句柄访问方式,java堆将会划分出来一部分内存去来作为句柄池,reference中存储的就是对象的句柄地址。而句柄中则包含...
  • 创建线程的第一种方式: 1,子类复写父类中的run方法。将线程需要运行的代码放到run()中。 2,创建子类对象的同时线程也被创建。 3,通过调用star()方法开启线程。 线程和线程任务是绑定在一起的,创建了4个线程...
  • 【方法一】调用 util 中 Random 类:定义Random的对象 rand,用 rand.nextInt()生成随机整数或者将 next 后面Int改为 Double,Float , Long,分别对应了双精度,单精度和长整形)注意只有nextInt( ) 可以带参数,...
  • 方法1:通过创建Thread类子类实现多线程,步骤如下 : ...3. 创建该子类一个线程对象。 4. 通过start( )方法启动线程 public class Hello_Java { public static void main(String[] args) { // TODO...
  • 上一篇文章《Java中synchronized实现对象的两种方式及原理解析》中,介绍了方法锁的两种实现方式及Synchronized的底层原理,本文将讲解synchronized的类锁的两种实现方式。 一.类锁的定义 什么是类锁 类锁指...
  • Java线程的两种创建方式及优劣比较

    千次阅读 2013-11-26 21:58:02
    1、通过实现Runnable接口线程创建 (1).定义一个类实现Runnable接口,重写接口中的run()方法。在run()方法中加入具体的任务代码或处理逻辑。...调用Thread对象的start()方法,启动线程。这种方式
  • Java定义两种方式: 实现Runnable 接口; 可以继承Thread类。实现Runnable接口创建线程最简单方法就是创建一个实现Runnable 接口类。Runnable抽象了一个执行代码单元。你可以通过实现Runnable接口方法...
  •  类成员变量在定义时初始化,那么每次创建这个类的对象时,该成员变量值都是固定为此值; 通过构造函数初始化,可以在创建该类对象时动态赋值,更加灵活。 2.代码执行顺序 在类被创建时,成员变量按照声明...
  • 代理(Proxy)是java设计模式中的其中一,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象. 这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能. 1.1.静态代理 静态...
  • Java中数组的定义与类与对象 ...1、二位数组的声明,两种方式 类型标识符 数组名[][] 类型标识符 [][]数组名 2、二维数组的初始化 (1)直接指定初值 (2)用关键字new初始化数组 ##二、类与对象的
  • Java使用java.lang.Thread类代表线程,所有线程对象都必须是Thread类或其子类实例。每个线程作用是完成一定任务,实际上就是执行一段程序流即一段顺序执行代码。Java使用线程执行体来代表这段程序流。 ...
  • C/C++创建对象的两种方式

    千次阅读 2016-12-24 15:58:49
    刚学C++肯定被其创建对象糊里糊涂,其不像Java那样直接通过new就可以创建对象了,而且还不需要人为去回收,但C++却不行其有两种方式创建对象:1、通过new创建类对象CTest* pTest = new CTest();delete pTest;...
  • java生成随机数的两种方式

    千次阅读 2015-06-07 09:22:11
    调用 util 中 Random 类:定义Random的对象 rand,用 rand.nextInt()生成随机整数 或者将 next 后面Int改为 Double,Float , Long,分别对应了双精度,单精度和长整形) 注意只有 nextInt( ) 可以带参数...
  • 由于reference类型在Java虚拟机规范中规定了一个指向对象的引用,并没定义何种方式去定位,访问堆中的对象的具体位置,所以对象的访问方式也是取决于虚拟机的实现而定的,目前主流的实现方式有使用句柄和直接指针...
  • Java中有两种不同对变量赋值方式,一种是直接将一个值赋给变量。例如:int a = 1;String s = "abc";Integer in = 125;另外一种是创建一个对象,并将其赋给一个变量。例如:String s = new String("abc")Integer ...
  • 1、两种方式 继承Thread和实现Runnable接口 a、Runnable是一个接口,该接口中只包含了一个run()方法。我们可以定义一个类A实现Runnable接口;然后,通过new Thread(new A())等方式新建线程,通过这种方式创建...
  • java中TreeSet的两种排序比较的方式

    千次阅读 2018-07-30 10:20:58
    第一是使得元素具有比较性 第二是让集合具有比较性 ...让元素对象的类具有比较性,并实现Comparable接口 * 2.对其中的compareto方法进行复写 * 3.在方法中定义返回1大于0等于-1小于 * 4.在主...
  • 三、创建多线程的两种方式 第一种, 通过继承Thread类创建线程类 1、定义一个类继承Thread类,并重写Thread类的run()方法,run()方法的方法体就是线程要完成的任务,因此把run()称为线程的执行体; 2、创建该类的实
  • 实现多线程的两种方式,一种是继承Thread类,一种是实现Runnable接口,有两个例子如下: 方式一: 方式二: 疑问: 为什么实现Runnable时,创建线程对象不能写成 " MyThread mt=new MyThread();...
  • Java是一纯粹的面向对象程序设计语言,除了基本数据类型(如整型、浮点型等),Javn中的数据都以对象的形式存在,将属性和操作封装在对象中,它没有游离于类之外的属性和方法,可以有效实现细节隐藏。 2)信息隐蔽,即尽...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,399
精华内容 559
关键字:

java对象的两种定义方式

java 订阅