精华内容
下载资源
问答
  • 不能直接使用类的特征被称为属性类的行为被称为方法(2)python的对象对象是由类创建出来的具体的一事物对象是由哪个创建的就拥有这个类的属性和方法2.python类的设计(1)类设计概述使用面向对象的编程思想进行开发...

    1.python中类和对象的基本概念

    (1)python的类

    类是对一类具有相同的特征和行为的事物的一个统称,是抽象的,不能直接使用

    类的特征被称为属性

    类的行为被称为方法

    (2)python的对象

    对象是由类创建出来的具体的某一事物

    对象是由哪个创建的就拥有这个类的属性和方法

    2.python类的设计

    (1)类设计概述

    使用面向对象的编程思想进行开发时,首先应该分析需求,确定程序中应该包含的类。在设计类时需要考虑三点:

    类名:使用大驼峰法命名。

    类的属性(特征)

    类的方法(行为)

    (2)类设计基本语法(只有方法,没有属性)

    class 类名:

    def 方法1(self, 参数列表):

    pass

    def 方法2(self, 参数列表):

    pass

    (3)创建对象语法

    对象变量 = 类名()

    (4)引用

    创建对象时,变量仍然是一个引用(存储了对象实际内存的地址),也就是变量引用了对象数据。

    在使用print函数打印一个变量名时,默认打印的是这个变量里存的地址(十六进制)

    (5)为对象设置属性

    在类的外部,使用对象名.属性=属性值,便可以为对象增加属性,但是不推荐这样做,程序容易出错。

    (6)self参数

    self相当于java中的this,谁(哪个对象)调用了这个方法,这个self就是谁的引用。

    调用方法时,程序员不需要传递self参数

    (7)访问对象的属性和调用对象的方法

    在类内部(类的方法内部)可以通过使用self.访问对象的属性和调用对象的方法

    在类的外部可以使用对象名.访问属性和方法

    3.dir内置函数

    python是完全面向对象的编程语言,其中所有的数据都是对象,包括之前遇见过的变量、函数、数据。

    验证方法:

    在标识符/数据后输入一个 .,然后按下 TAB 键,iPython 会提示该对象能够调用的方法列表。

    使用内置函数dir 传入标识符 / 数据,可以查看对象内的所有属性及方法。

    下述__方法名__格式是Python提供的内置方法/属性,常用的内置方法:

    __new__() #创建对象时,会被自动调用

    __init__() #对象被初始化时,会被自动调用

    __del__() #对象被从内存中销毁前,会被自动调用

    __str__() #返回对象的描述信息,print函数输出使用

    注意:

    如果希望对象在销毁之前做一些事情,可以考虑使用__del__()方法。一个对象的生命周期就是从创建到销毁的这段时间内。

    在对象的生命周期内,可以访问对象属性,调用对象的方法。

    当打印一个对象的引用时,默认打印的是这个对象的地址,如果想要打印这个对象的相关内容信息,可以使用__str__()方法改造这个对象。该方法必须返回一个字符串。

    4.对象的创建过程

    当变量=类名()创建一个对象时,会自动执行一下操作:

    为对象分配内存空间(创建对象)

    为对象设置初始值(调用初始化方法__init__())

    5.定义属性、私有属性、私有方法、初始化

    (1)为对象定义属性

    在__init__()方法内部使用 self.属性名 = 属性的初始值就可以定义属性

    (2)创建对象时设置初始值

    在开发中,如果希望在 创建对象的同时,就设置对象的属性,可以对__init__()方法进行 改造

    把希望设置的属性值,定义成 __init__(self,参数1,参数2...)方法的参数

    在方法内部使用 self.属性 = 形参 接收外部传递的参数

    在创建对象时,使用类名(参数1, 参数2...)调用

    (3)私有属性和私有方法的定义

    实际开发时有些方法或属性不希望被外部对象访问到,只在本对象内部使用,可以将这些方法或属性设置为私有方法和私有属性。

    定义方式:

    在定义属性或方法时,在属性名或者方法名前增加两个下划线,定义的就是私有属性或方法。

    展开全文
  • 1.变量的线程安全性与变量的作用域有关。 2.对象 对象是类型的实例 ...调试状态下,如果多个线程都创建某实例的对象,每个对象都调用自身方法,调试是,会发现是访问的同一个代码,多个线程是有冲突的...

       1.变量的线程安全性与变量的作用域有关。

       2.对象 

         对象是类型的实例

         在创建对象时,会单独有内存区域存储对象的属性和方法。所以,一个类型的多个实例,在执行时,只要没有静态变量的参与,应该都是线程安全的。

    这跟我们调试状态下,是不一样的。调试状态下,如果多个线程都创建某实例的对象,每个对象都调用自身方法,在调试是,会发现是访问的同一个代码,多个线程是有冲突的。但是,真正的运行环境是线程安全的。

          以销售员为例,假设产品是充足的,多个销售员,销售产品,调用方法:Sale(),其是线程安全的。

          但是,如果涉及到仓库,必须仓库有足够的产品才能进行销售,这时,多个销售人员就有了临界资源:仓库。

          在这里我们只讨论对象的普通方法。至于方法传入的参数,以及方法内对静态变量操作的,这里需要根据参数和静态变量来判定方法的线程安全性。

          销售员案例:

    复制代码
    using System;
    using System.Threading;
    
    namespace MutiThreadSample.Sale
    {
        /// <summary>
        /// 销售
        /// </summary>
        public class Saler
        {
            /// <summary>
            /// 名称
            /// </summary>
            public string Name { get; set; }
            /// <summary>
            /// 间隔时间
            /// </summary>
            public int IntervalTime { get; set; }
            /// <summary>
            /// 单位时间销售运量
            /// </summary>
            public int SaleAmount { get; set; }
            /// <summary>
            /// 销售
            /// </summary>
            public void Sale()
            {
                Console.WriteLine("销售:{0} 于 {1} 销售产品 {2}", this.Name, DateTime.Now.Millisecond, this.SaleAmount);
                Thread.Sleep(IntervalTime);
            }
            /// <summary>
            /// 销售
            /// </summary>
            /// <param name="interval">时间间隔</param>
            public void Sale(object obj)
            {
                WHouseThreadParameter parameter = obj as WHouseThreadParameter;
                if (parameter != null)
                {
                    while (parameter.WHouse != null && parameter.WHouse.CanOut(this.SaleAmount))
                    {
                        parameter.WHouse.Outgoing(this.SaleAmount);
                        Console.WriteLine("Thread{0}, 销售:{1} 于 {2} 销售出库产品 {3}", Thread.CurrentThread.Name, this.Name, DateTime.Now.Millisecond, this.SaleAmount);
                        Thread.Sleep(this.IntervalTime);
                    }
                }
            }
         }
    }
    复制代码

          3静态类型

          已经讲了类的实例--对象的多线程安全性问题。这里只讨论类型的静态变量和静态方法。

          当静态类被访问的时候,CLR会调用类的静态构造器(类型构造器),创建静态类的类型对象,CLR希望确保每个应用程序域内只执行一次类型构造器,为了做到这一点,在调用类型构造器时,CLR会为静态类加一个互斥的线程同步锁,因此,如果多个线程试图同时调用某个类型的静态构造器时,那么只有一个线程可以获得对静态类的访问权,其他的线程都被阻塞。第一个线程执行完 类型构造器的代码并释放构造器之后,其他阻塞的线程被唤醒,然后发现构造器被执行过,因此,这些线程不再执行构造器,只是从构造器简单的返回。如果再一次调用这些方法,CLR就会意识到类型构造器被执行过,从而不会在被调用。

          调用类中的静态方法,或者访问类中的静态成员变量,过程同上,所以说静态类是线程安全的。

          最简单的例子,就是数据库操作帮助类。这个类的方法和属性是线程安全的。

     

    复制代码
    using System;
    
    namespace MutiThreadSample.Static
    {
        public class SqlHelper
        {        
            /// <summary>
            /// 数据库连接
            /// </summary>
            private static readonly string ConnectionString = "";
            /// <summary>
            /// 执行数据库命令
            /// </summary>
            /// <param name="sql">SQL语句</param>
            public static void ExcuteNonQuery(string sql)
            { 
                //执行数据操作,比如新增、编辑、删除
            }
        }
    }
    复制代码

     

           但是,对于静态变量其线程安全性是相对的,如果多个线程来修改静态变量,这就不一定是线程安全的。而静态方法的线程安全性,直接跟传入的参数有关。

           总之:

          针对变量、对象、类型,说线程安全性,比较笼统,在这里,主要是想让大家明白,哪些地方需要注意线程安全性。对于变量、对象(属性、方法)、静态变量、静态方法,其线程安全性是相对的,需要根据实际情况而定。

         万剑不离其宗,其判定标准:是否有临界资源。

     4、集合类型是线程安全的吗?

          常用的集合类型有List、Dictionary、HashTable、HashMap等。在编码中,集合应用很广泛中,常用集合来自定义Cache,这时候必须考虑线程同步问题。 

          默认情况下集合不是线程安全的。在System.Collections 命名空间中只有几个类提供Synchronize方法,该方法能够超越集合创建线程安全包装。但是,System.Collections命名空间中的所有类都提供SyncRoot属性,可供派生类创建自己的线程安全包装。还提供了IsSynchronized属性以确定集合是否是线程安全的。但是ICollection泛型接口中不提供同步功能,非泛型接口支持这个功能。

         Dictionary(MSDN解释)

         此类型的公共静态(在 Visual Basic 中为 Shared)成员是线程安全的。 但不保证所有实例成员都是线程安全的。
         只要不修改该集合,Dictionary<TKey, TValue> 就可以同时支持多个阅读器。 即便如此,从头到尾对一个集合进行枚举本质上并不是一个线程安全的过程。 当出现枚举与写访问互相争用这种极少发生的情况时,必须在整个枚举过程中锁定集合。 若允许多个线程对集合执行读写操作,您必须实现自己的同步。

          很多集合类型都和Dictionary类似。默认情况下是线程不安全的。当然微软也提供了线程安全的Hashtable.

          HashTable 

          Hashtable 是线程安全的,可由多个读取器线程和一个写入线程使用。 多线程使用时,如果只有一个线程执行写入(更新)操作,则它是线程安全的,从而允许进行无锁定的读取(若编写器序列化为 Hashtable)。 若要支持多个编写器,如果没有任何线程在读取 Hashtable 对象,则对 Hashtable 的所有操作都必须通过 Synchronized 方法返回的包装完成。

          从头到尾对一个集合进行枚举本质上并不是一个线程安全的过程。 即使某个集合已同步,其他线程仍可以修改该集合,这会导致枚举数引发异常。 若要在枚举过程中保证线程安全,可以在整个枚举过程中锁定集合,或者捕捉由于其他线程进行的更改而引发的异常。

         线程安全起见请使用以下方法声明

            /// <summary>
            ///  Syncronized方法用来创造一个新的对象的线程安全包装
            /// </summary>
            private Hashtable hashtable = Hashtable.Synchronized(new Hashtable());

        在枚举读取时,加lock,这里lock其同步对象SyncRoot 

    复制代码
            /// <summary>
            /// 读取
            /// </summary>
            public void Read()
            { 
                lock(hashtable.SyncRoot)
                {
                    foreach (var item in hashtable.Keys)
                    {
                        Console.WriteLine("Key:{0}",item);
                    }
                }
            }
    复制代码

    转载于:https://www.cnblogs.com/bile/p/6114506.html

    展开全文
  • 一、选择题(每小题3分,共60分) (1到15为单选,16到20为多选)1、在创建某类的对象时 应该( C)A、先声明对象,然后才能使用对象B、先声明对象,为对象分配内存空间,然后才能使用对象C、先声明对象,为对象分配内存...

    一、选择题(每小题3分,共60分) (1到15为单选,16到20为多选)

    1、在创建某类的对象时 应该( C)

    A、先声明对象,然后才能使用对象

    B、先声明对象,为对象分配内存空间,然后才能使用对象

    C、先声明对象,为对象分配内存空间,对对象初始化,然后才能使用对象

    D、以上述说法都不对

    2、Java应用程序经过编译后会产生一个以(B)为扩展名的字节码文件

    A、.java B、.class C、.exe D、.html

    3、已知有数组定义:int MyArray[] = {10,20,30,40,50,60,70,80,90,100},则以下程序段:

    int s = 0 ;

    for ( int i = 0 ; i < MyArray.length ; i + + )

    if ( i % 2 = = 1 )

    s =s+ MyArray[i] ;

    System.out.println( s );

    执行后s的值是(C)

    A、200 B、250 C、300 D、350 E、程序编译出错

    4、给定以下程序段,如下:

    int i=0,j=-1;

    switch(i){

    case 0:j=1;

    case 2:j=2;

    default:j=5;

    }

    System.out.print("j="+j);

    编译运行,正确的是( D)

    A、j=-1 B、j=1 C、j=2 D、j=5

    5、有如下程序段:

    String unset=null;

    if(unset!=null && unset.length()>5){

    System.out.println("Hello Pido! ");

    }

    则执行以上程序段后,以下选项描述正确的是( D)

    A、运行时出现错误 B、编译正确但运行时空指针异常

    C、编译时出现空指针异常 D、没有任何错误出现

    6、有以下程序段:

    int i = 0;

    for(;i<100;i++){

    if(i==10){break;}

    }

    System.out.println("i="+i);

    则执行后程序的输出结果为( B)

    A、i=10 B、10 C、9 D、i=9

    7、如下Java程序片段

    String a = "abcdefg"; String b = "abcdefg";

    System.out.println(a==b);

    运行后,该程序段的输出结果是(B )

    A、true B、false C、0 D、编译出错

    8、分析下面的Java程序段:

    class testException{

    int sum=0;

    public static void main(String args[]){

    int n[]={0,1,2,3,4};

    for(int i=1;i<=4;i++){

    sum=sum+n[i];

    }

    System.out.println("sum="+sum);

    }

    }

    输出结果将是(D )

    A、10 B、sum=10 C、运行时报错 D、编译出错

    9、有如下Java程序声明

    String s1=new String(“pido”);

    String s2=new String(“online”);

    String s3=new String("0");

    以下选项中能够通过编译的是( A)

    A、s3=s1+s2 B、s3=s1&s2 C、s3=s1||s2 D、s3=s1&&s2

    10、在单一文件中import、class和package的正确出现顺序是( A)

    A、package, import, class B、class, import, package

    C、import, package, class D、package, class, import

    11、下面的Java变量名既符合规则又符合规范的是( D)。

    A、myString B、ab C、$mystring D、MyString

    12、阅读下面代码片段,输出结果是(A)。

    StringBuffer sb = new StringBuffer("Hello");

    String t = " MY";

    t = t + " FRIEND";

    sb.append(t);

    System.out.println(sb.toString().toLowerCase().toLowerCase());

    A. my friend hello

    B. Hello MY FRIEND

    C. 程序报错

    D. hello my friend

    13、声明s1; String s1 = new String("phenobarbital");

    经过下面代码之后,

    String s2 = s1.substring(3, s1.indexOf("p"));

    s2的值是(D)。

    A、null B、"phen" C、"nobarbital" D、程序报错

    14、代码执行如下的程序输出的结果是( C)

    int num[] ={1,2,3,4,5,6};

    int sum=0;

    for(int i=0;i

    if(num[i]%2=0){

    sum=sum+num[i];

    }

    }

    System.out.println(sum);

    A、12 B、22 C、编译出错 D、20

    15、运行下面这段代码,输出结果是(B)。

    public class MyTest {

    int x = 30;

    public static void main(String args[]){

    int x = 20;

    MyTest ta = new MyTest();

    ta.Method(x);

    System.out.print(x);

    }

    public void Method(int z){

    int y = z*z+x;

    System.out.print(y);

    }

    }

    A、93030 B、 43020 C、92030 D、 42030

    16、以下代码第(BC)行有错误

    int[] list = new int[10]; 第1行

    StringBuffer sb = new String (""); 第2行

    // 产生0-99的随机数 第3行

    int num; 第4行

    for (int i = 0; i < 10; i++) { 第5行

    num = Math.random() * 100; 第6行

    list[i] = num; 第7行

    sb.append(num + " "); 第8行

    } 第9行

    A、第1行 B、第2行 C、第6行 D、第8行 E、第5行

    17、阅读下面代码,其中说法正确的是(DE)。

    public int guessWhat( double arr[ ] ){

    double x= 0;

    for( int i = 0; i < arr.length; i++ ){

    if(x > arr[i]){

    x = arr[i];

    }

    }

    return x;

    }

    A、返回数组最大值的下标

    B、返回数组最小值的下标

    C、返回数组中的最大值

    D、返回数组中的最小值

    E、参数可以是int类型的数组

    F、参数可以是String类型的数组

    18、关于下面代码,说法正确的是(ED)。

    public class Test {

    int x=10; 第1行

    public static void main(String[ ] args1){ 第2行

    Test test = new Test(); 第3行

    int x = 11; 第4行

    if (test.methodA()){ 第5行

    x++; 第6行

    System.out.println(x); 第7行

    } 第8行

    } 第9行

    public boolean methodA(){ 第10行

    System.out.println(x++); 第11行

    return true; 第12行

    } 第13行

    } 第14行

    A、第4行有编译错误

    B、第5行有编译错误

    C、第12行有编译错误

    D、运行输出12

    E、运行输出10

    F、运行输出11

    19、关于下面代码,说法正确的是(BD)

    String space = " ";

    String composite = space +space+ "a" + space +"b"+ space; System.out.println("AB".equalsIgnoreCase(composite.substring(1).trim().toUpperCase()));

    A、编译报错

    B、输出结果为false

    C、输出结果为true

    D、其中"AB"是对象

    E、其中"AB"不是对象

    20、关于类的方法使用下列那些描述是正确的(AEC)

    A、在类中调用本类的方法可以直接通过方法名调用。

    B、在类中调用本类的方法不可以直接通过方法名调用,必须要通过对象。

    C、在类中调用本类的方法可以通过对象.方法名调用。

    D、不同类之间方法可以直接通过方法名调用。

    E、不同类之间方法可以通过对象.方法名调用。

    二、填空题(每空2分,共20分)

    1、设x=2.5,a=7,则表达式x+a%3*7的值为_____9.5_____;

    2、输入一个正整数,输出该数的阶乘。求整数n的阶乘公式为:n!=12…*n。(n!表示n的阶乘)

    System.out.print("输入一个正整数:");

    Scanner input = new Scanner(System.in);//省略导入包

    int number = input.nextInt();

    int result = 1;

    for (_________________) {

    __________________

    }

    3、int a[]={1,2},b=2,i=0;则a[i++]+=b;执行后:i=__________ ,a[i]= __________;

    4、如下程序段

    class A{

    int var1=1; int var2;

    public static void main(String args[]) {

    int var3=3; A a=new A();

    System.out.println(a.var1+a.var2+var3);

    }

    }的运行结果是__________;

    5、"mypido".equals(new String("mypido"))的返回结果是__________(填true或false);

    6、如下Java程序段

    char c=’a’;

    switch (c) {

    case ’a’: System.out.print("pido");

    default: System.out.print(" online");

    }的运行结果是__________;

    7、程序段int i=1; int j=i++; if((i>++j)&&(i++==j)) i=i+j; 运行后i的值是__________(此空4分);

    三、程序分析题(每小题5分,共10分)

    1、写出以下程序的运行结果。

    public class EqualOrNot{

    public static void main(String[] args) {

    B b1=new B();

    B b2=new B();

    b1.c(5);

    b2.c(5);

    System.out.println(b1==b2);

    System.out.println(b1.equals(b2));

    System.out.println(b1.x==b2.x);

    }

    }

    class B{

    int x;

    public void c( int y){ x=y; }

    }

    2、写出以下程序的运行结果。

    int i = 0, j = 0;

    while(i<5){

    if(j>2){

    System.out.println("**");

    i++;

    j--;

    continue;

    }

    System.out.println("*");

    j++;

    i++;

    }

    四、 编程题(共10分)

    1、需求:在包myjava.test中创建个类名为People的类 ,属性为年龄(age)默认值20,

    在这个类中有个方法myAge其功能是通过参数接收一个数值,与属性age进行比较

    如果接受的数值大则返回“你猜我的年龄也太老了吧”否则返回“我可没这么小”,相等则返回“你真厉害,一下就猜中了”。编写测试类调用myAge方法(程序框架要完整)

    展开全文
  • java程序设计试卷Ajava程序设计试卷A一、选择题(每小题2分,共30分) 1、在创建某类的对象时 应该( ) A、先声明对象,然后才能使用对象 B、先声明对象,为对象分配内存空间,然后才能使用对象 C、先声明对象,为对象...

    java程序设计试卷A

    java程序设计试卷A

    一、选择题(每小题2分,共30分) 1、在创建某类的对象时 应该( ) A、先声明对象,然后才能使用对象 B、先声明对象,为对象分配内存空间,然后才能使用对象 C、先声明对象,为对象分配内存空间,对对象初始化,然后才能使用对象 D、以上述说法都对 2、以下说法中对Java中 定义的父类与子类的关系描述正确是的( ) A、一个子类可以有多个父类,一个父类也可以有多个子类 B、一个子类可以有多个父类,但一个父类只可以有一个子类 C、一个子类可以有一个父类,但一个父类可以有多个子类 D、上述说法都不对 3、给定如下Java 程序片断: class A{ public A(){ System.out.println("pido"); }} class B extends A{ public B(){ System.out.println(" online"); }public static void main(String[] args){ B b=new B(); }}上述程序将( ) A、不能通过编译 B、通过编译,输出为: pido onlineC、通过编译,输出为: online D、通过编译,输出为: pido4、给定以下程序段,如下: int i=0,j=-1;switch(i){ case 0:j=1; case 2:j=2; default:j=5; }System.out.print("j="+j); 编译运行,正确的是( ) A、j=-1 B、j=1 C、j=2 D、j=55、下面关于Java构造函数的描述正确的是 ( ) A、类必须有显式定义构造函数 B、它的返回类型是void C、它和类有相同的名称,但它不能带任何参数 D、以上描述都是错误的 6、在Java编程中,用来执行Java类文件的命令是( ) A、javac B、java C、appletviewer D、以上都不对 7、如下程序片段,体现了Java的( )概念 public void aMethod(String s) {........}public void aMethod(int i) {........}public void aMethod(int I,float f) {........}A、多继承 B、重载 C、重写  D、多态 8、如下Java升序片段 Integer a = new Integer(3); Integer b = new Integer(3);System.out.println(a==b); 运行后,该程序段的输出结果是( ) A、true B、false C、0 D、19、分析下面的Java程序段: class testException{ public static void main(String args[]){ int n[]={0,1,2,3,4}; int sum=0; try { for(int i=1;i<5;i++) sum=sum+n[i]; System.out.println("sum="+sum); }catch(ArrayIndexOutOfBoundsException e) { System.out.println("数组越界"); }finally{ System.out.println("程序结束"); }}}输出结果将是( ) A、10 数组越界 程序结束 B、10 程序结束 C、数组越界 程序结束 D、程序结束 10、有如下Java程序声明 String s1=new String(“pido”);String s2=new String(“online”);String s3=new String("0"); 以下选项中能够通过编译的是( ) A、s3=s1+s2 B、s3=s1&s2 C、s3=s1||s2 D、s3=s1&&s211、从下面的布局管理器中选择按行放置控件、从左到右、从上到下,当一行装满时开始新的一行的布局管理器 ( ) A、CardLayout B、FlowLayout C、BorderLayout D、GridLayout 12、选择正确生成text field的代码,此text field最多能够显示10个字符(假定其字体有固定大小)并最初显示“pido”串( ) A、new TextField("pido", 10) ; B、new TextField(10,"pido"); C、new TextField("pido",max,10);

    展开全文
  • 一、选择题(每小题3分,共60分) (1到15为单选,16到20为多选)1、在创建某类的对象时 应该( C)A、先声明对象,然后才能使用对象B、先声明对象,为对象分配内存空间,然后才能使用对象C、先声明对象,为对象分配内存...
  • java试卷A

    千次阅读 2017-03-22 16:51:02
    试卷A 班级________ 姓名__毛佑福__ 分数_________ ...1、在创建某类的对象时 应该( C) A、先声明对象,然后才能使用对象 B、先声明对象,为对象分配内存空间,然后才能使用对象 C、先声明对象,为对象分
  • 了解工厂模式都知道,工厂模式就是用于大量创建某种,某类,或者某批对象时的一种优秀解决方案。本文介绍“抽象工厂模式”就是工厂模式一种体现,是属于建造型模式一种。 抽象工厂模式中有四个角色:分别...
  • 抽象和接口区别

    2018-06-27 22:45:03
    面向对象的设计,复用的重点其实应该是抽象层的复用,而不是具体一个代码块的复用。 面向对象的概念中,我们知道所有的对象都是通过来描绘的,但是反过来却不是这样。 并不是 所有的都是用来描绘对象...
  • 构造函数是实例化对象时用来初始化对象,所有构造函数都包含一个名为“prototype”不可枚举属性,这个属性就是原型(prototype),JavaScript就是使用它来实现基于原型继承...
  • 创建线程的Runnable接口方法 public interface ... 设计该接口的目的是为希望活动执行代码的对象提供一个公共协议。例如,Thread 实现了 Runnable。激活的意思是说某个线程已启动并且尚未停止。 此外,
  • 然后可以分配该类的实例,在创建Thread作为一个参数来传递并启动 Thread(Runnable target)分配新的Thread对象 Thread(Runnable target,String name)分配新的Thread对象 Runnable 接口应该由那些打算通过一...
  • 【05-面向对象(下)】

    2018-07-03 21:42:31
    •静态内部类的对象寄存外部类里,非静态内部类的对象寄存外部类实例里 使用内部类 •1.外部类内部使用内部类-不要外部类的静态成员中使用非静态内部类,因为静态成员不能访问非静态成 员。 ...
  • 对象的初始化(1) 非静态对象的初始化在创建对象时,对象所在类的所有数据成员会首先进行初始化。基本类型:int型,初始化为0。如果为对象:这些对象会按顺序初始化。※在所有类成员初始化完成之后,才调用本类的构造...
  • PHP抽象 介绍

    2020-12-19 10:19:53
    自然语言中,我们理解抽象的概念是,一个物体的一种大的描述,这种描述对某类物体来说是共有的特性。那么PHP中也是一样的,我们把一个类进行抽象,可以指明类的一般行为,这个类应该是一个模板,它指示它的子...
  • HotSpot虚拟机对象探秘对于Java程序员来讲,实际开发过程中,new指令应该是使用的最多的指令之一了,当我们需要使用一个类的实例,就可以使用new指令创建出这个类的实例,但是对于虚拟机来说,当我们使用new...
  • 客户程序调用一个类时,它是不会考虑这个是否只能有一个实例等问题,所以,这应该设计者责任,而不是使用者责任。  从另一个角度来说,Singleton模式其实也是一种职责型模式。因为我们创建了一...
  • 第一种方法非常直观:只需将要复用的类的对象引用放在新类中即可,这种方法称为组合。第二种方法则更加细致:它按照现有类的类型来创建新类,这种方法称为继承。实际上进行程序设计应该优先考虑组合而不是继承...
  • 客户程序调用一个类时,它是不会考虑这个是否只能有一个实例等问题,所以,这应该设计者责任,而不是使用者责任。 从另一个角度来说,Singleton模式其实也是一种职责型模式。因为我们创建了一个...
  • 客户程序 调用一个类时,它是不会考虑这个是否只能有一个实例等问题,所以,这应该设计者责任,而不是使用者责任。从另一个角度来说,Singleton模式其实也是一种职责模式。因为我们创建了一个对象...
  • 客户程序调用一个类时,它是不会考虑这个是否只能有一个实例等问题,所以,这应该设计者责任,而不是使用者责任。从另一个角度来说,Singleton模式其实也是一种职责模式。因为我们创建了一个对象...
  • 如何设计-封装

    2020-08-15 18:16:18
    那么根据类创建theDog对象height实例变量将可以直接修改,且无法增加任何校验,若异常情况导致theDog.height=0语句出现,该语句将执行成功,并引发不可预知错误场景。 根据封装基本原则,应该将Dog...
  • 概述Singleton模 式要求一个类有且仅有一个实例...因为我们创建了一个对象,这个对象扮演了独一无二的角色,这个单独的对象实例中,它集中了它所属类的所有权力,同时它也肩负了行使这种权力的职责!意图保证一个类
  • 注意: ExecuteXmlReader 不支持连接字符串,因为:与 SqlDataReader 对象不同,XmlReader 对象在 XmlReader 关闭没有提供自动关闭连接方法。如果客户端传递了连接字符串,那么当客户端完成对 XmlReader 操作...

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 278
精华内容 111
关键字:

在创建某类的对象时应该