class 订阅
CLASS是一种在网络工程中的一种协议。一般组词为“CLASSLESS”(无类)或者“CLASSFUL”(有类)。面向对象编程中一个无明显特点的范畴,用于描述一组更具体的称为对象的东西。另有日本乐队组合名称也为CLASS。同时,class也是C++语言中的关键字,在matlab中class用于获取变量的类型。 展开全文
CLASS是一种在网络工程中的一种协议。一般组词为“CLASSLESS”(无类)或者“CLASSFUL”(有类)。面向对象编程中一个无明显特点的范畴,用于描述一组更具体的称为对象的东西。另有日本乐队组合名称也为CLASS。同时,class也是C++语言中的关键字,在matlab中class用于获取变量的类型。
信息
外文名
CLASS
一般组词
CLASSLESS CLASSFUL
释    义
网络工程中的一种协议
所属学科
网络工程
CLASS简介
CLASS是在网工中经常与协议相连。一个类为定义一种特定对象的行为提供了模板(扩展名).java文件被编译后生成.class文件。
收起全文
精华内容
参与话题
问答
  • Class的基本用法

    千次阅读 2018-07-19 18:25:05
    Class(类)这个概念,作为对象的模板。class可以看作只是一个语法糖,通过class关键字,可以定义类。让对象原型的写法更加清晰、更像面向对象编程的语法。类和模块的内部,默认就是严格模式,所以不需要使用use ...

    Class(类)这个概念,作为对象的模板。class可以看作只是一个语法糖,通过class关键字,可以定义类。让对象原型的写法更加清晰、更像面向对象编程的语法。类和模块的内部,默认就是严格模式,所以不需要使用use strict指定运行模式。

    1.constructor方法和实例对象

    //定义类
    class Point {
      constructor(x, y) {
        this.x = x;
        this.y = y;
      }
    
      toString() {
        return '(' + this.x + ', ' + this.y + ')';
      }
    }

    ES6 的类,完全可以看作构造函数的另一种写法。类的数据类型就是函数,类本身就指向构造函数。使用的时候,也是直接对类使用new命令,跟构造函数的用法完全一致。类必须使用new调用,否则会报错。

    class Point {
      // ...
    }
    
    typeof Point // "function"
    Point === Point.prototype.constructor // true   prototype对象的constructor属性,直接指向“类”的本身,这与 ES5 的行为是一致的。
    
    class Bar {
      doStuff() {
        console.log('stuff');
      }
    }
    
    var b = new Bar();
    b.doStuff() // "stuff"

    类的所有方法都定义在类的prototype属性上面。在类的实例上面调用方法,其实就是调用原型prototype对象上的方法,所以类的新方法可以添加在prototype对象上面。Object.assign方法可以很方便地一次向类添加多个方法。

    class Point {
      constructor() {
      }
    
      toValue() {
      }
    }
    
    // 等同于
    
    Point.prototype = {
      constructor() {},
      toValue() {},
    };
    
    
    Object.assign(Point.prototype, {
      toString(){},
    });

    类的内部所有定义的方法,都是不可枚举的。

    class Point {
      constructor(x, y) {
      }
    
      toString() {
      }
    }
    
    Object.keys(Point.prototype)// []
    Object.getOwnPropertyNames(Point.prototype)// ["constructor","toString"]
    
    
    var Point = function (x, y) {
    };
    
    Point.prototype.toString = function() {
    };
    
    Object.keys(Point.prototype)// ["toString"]
    Object.getOwnPropertyNames(Point.prototype)// ["constructor","toString"]

    类的属性名,可以采用表达式。constructor方法是类的默认方法,通过new命令生成对象实例时,自动调用该方法。一个类必须有constructor方法,如果没有显式定义,一个空的constructor方法会被默认添加。constructor方法默认返回实例对象(即this),完全可以指定返回另外一个对象。

    let methodName = 'getArea';
    
    class Square {
      constructor(length) {
      }
    
      [methodName]() {
      }
    }
    class Point {
    }
    
    // 等同于
    class Point {
      constructor() {}
    }
    
    class Foo {
      constructor() {
        return Object.create(null);
      }
    }
    
    new Foo() instanceof Foo
    // false   constructor函数返回一个全新的对象,结果导致实例对象不是Foo类的实例。

    与 ES5 一样,实例的属性除非显式定义在其本身(即定义在this对象上),否则都是定义在原型上(即定义在class上)。此外,类的所有实例共享一个原型对象,这也意味着,可以通过实例的__proto__属性为“类”添加方法。

    //定义类
    class Point {
    
      constructor(x, y) {
        this.x = x;
        this.y = y;
      }
    
      toString() {
        return '(' + this.x + ', ' + this.y + ')';
      }
    
    }
    
    var point = new Point(2, 3);
    
    point.toString() // (2, 3)
    
    point.hasOwnProperty('x') // true
    point.hasOwnProperty('y') // true
    point.hasOwnProperty('toString') // false
    point.__proto__.hasOwnProperty('toString') // true
    
    
    var p1 = new Point(2,3);
    var p2 = new Point(3,2);
    
    p1.__proto__ === p2.__proto__//true
    //__proto__ 并不是语言本身的特性,这是各大厂商具体实现时添加的私有属性,虽然目很多浏览器的 JS 引擎中都提供了这个私有属性,但不建议在生产中使用该属性,避免对环境产生依赖。生产环境中,我们可以使用 Object.getPrototypeOf 方法来获取实例对象的原型,然后再来为原型添加方法/属性。
    var p1 = new Point(2,3);
    var p2 = new Point(3,2);
    
    p1.__proto__.printName = function () { return 'Oops' };
    
    p1.printName() // "Oops"
    p2.printName() // "Oops"
    
    var p3 = new Point(4,2);
    p3.printName() // "Oops"
    
    //在p1的原型上添加了一个printName方法,由于p1的原型就是p2的原型,因此p2也可以调用这个方法。而且,此后新建的实例p3也可以调用这个方法。这意味着,使用实例的__proto__属性改写原型,必须相当谨慎,因为这会改变“类”的原始定义,影响到所有实例。

    2.Class表达式:与函数一样,类也可以使用表达式的形式定义。

    //这个类的名字是MyClass而不是Me,Me只在 Class 的内部代码可用,指代当前类。如果类的内部没用到的话,可以省略Me。
    const MyClass = class Me {
      getClassName() {
        return Me.name;
      }
    };
    
    let inst = new MyClass();
    inst.getClassName() // Me
    Me.name // ReferenceError: Me is not defined

    采用 Class 表达式,可以写出立即执行的 Class。

    let person = new class {
      constructor(name) {
        this.name = name;
      }
    
      sayName() {
        console.log(this.name);
      }
    }('张三');
    
    person.sayName(); // "张三"

    3.不存在变量提升:

    new Foo(); // ReferenceError  Foo类使用在前,定义在后,这样会报错,因为 ES6 不会把类的声明提升到代码头部。
    class Foo {}
    
    {
      let Foo = class {};
      class Bar extends Foo {
      }
    } //因为Bar继承Foo的时候,Foo已经有定义了。
    

    4.私有方法和私有属性

    //1.在命名上加以区别
    class Widget {
    
      // 公有方法
      foo (baz) {
        this._bar(baz);
      }
    
      // 私有方法
      _bar(baz) {//表示这是一个只限于内部使用的私有方法。但是,这种命名是不保险的,在类的外部,还是可以调用到这个方法。
    
    
        return this.snaf = baz;
      }
    
      // ...
    }
    
    //2.将私有方法移出模块
    class Widget {
      foo (baz) {
        bar.call(this, baz);
      }
    
      // ...
    }
    
    function bar(baz) {
      return this.snaf = baz;
    }
    
    //3.利用Symbol值的唯一性,将私有方法的名字命名为一个Symbol值。
    const bar = Symbol('bar');
    const snaf = Symbol('snaf');
    
    export default class myClass{
    
      // 公有方法
      foo(baz) {
        this[bar](baz);
      }
    
      // 私有方法
      [bar](baz) {
        return this[snaf] = baz;
      }
    
      // ...
    };
    
    //新的前缀#表示私有属性,而没有采用private关键字,是因为 JavaScript 是一门动态语言,使用独立的符号似乎是唯一的可靠方法,能够准确地区分一种属性是否为私有属性。
    
    class Foo {
      #a;
      #b;
      #sum() { return #a + #b; }
      printSum() { console.log(#sum()); }
      constructor(a, b) { #a = a; #b = b; }
    }

    5.this的指向:类的方法内部如果含有this,它默认指向类的实例。

    class Logger {
      printName(name = 'there') {
        this.print(`Hello ${name}`);
      }
    
      print(text) {
        console.log(text);
      }
    }
    
    const logger = new Logger();
    const { printName } = logger;
    printName(); // TypeError: Cannot read property 'print' of undefined 
    //printName方法中的this,默认指向Logger类的实例。但是,如果将这个方法提取出来单独使用,this会指向该方法运行时所在的环境,因为找不到print方法而导致报错。

    解决this找不到的方法:1)构造方法中绑定this  2)使用箭头函数   3)使用Proxy,获取方法的时候,自动绑定this。

    class Logger {
      constructor() {
        this.printName = this.printName.bind(this);
      }
    }
    
    class Logger {
      constructor() {
        this.printName = (name = 'there') => {
          this.print(`Hello ${name}`);
        };
      }
    }
    
    function selfish (target) {
      const cache = new WeakMap();
      const handler = {
        get (target, key) {
          const value = Reflect.get(target, key);
          if (typeof value !== 'function') {
            return value;
          }
          if (!cache.has(value)) {
            cache.set(value, value.bind(target));
          }
          return cache.get(value);
        }
      };
      const proxy = new Proxy(target, handler);
      return proxy;
    }
    
    const logger = selfish(new Logger());

    6.class的取值函数getter和取值函数setter,存值函数和取值函数是设置在属性的 Descriptor描述 对象上的。

    class MyClass {
      constructor() {
        // ...
      }
      get prop() {
        return 'getter';
      }
      set prop(value) {
        console.log('setter: '+value);
      }
    }
    
    let inst = new MyClass();
    
    inst.prop = 123;
    // setter: 123
    
    inst.prop
    // 'getter'

    7.class的静态方法:类相当于实例的原型,所有在类中定义的方法,都会被实例继承。如果在一个方法前,加上static关键字,就表示该方法不会被实例继承,而是直接通过类来调用,这就称为“静态方法”。

    class Foo {
      static classMethod() {
        return 'hello';
      }
    }
    
    Foo.classMethod() // 'hello'
    
    var foo = new Foo();
    foo.classMethod()// TypeError: foo.classMethod is not a function
    
    
    //如果静态方法包含this关键字,这个this指的是类,而不是实例。静态方法可以与非静态方法重名。
    class Foo {
      static bar () {
        this.baz();
      }
      static baz () {
        console.log('hello');
      }
      baz () {
        console.log('world');
      }
    }
    
    Foo.bar() // hello   静态方法bar调用了this.baz,这里的this指的是Foo类,而不是Foo的实例,等同于调用Foo.baz。

    父类的静态方法,可以被子类继承,可以从super对象上调用。

    class Foo {
      static classMethod() {
        return 'hello';
      }
    }
    
    class Bar extends Foo {
      static classMethod() {
        return super.classMethod() + ', too';
      }
    }
    Bar.classMethod() // "hello, too"
    

    8.class的静态属性和实例属性(Class 内部只有静态方法,没有静态属性)

    (1)类的实例属性:类的实例属性可以用等式,写入类的定义之中。

    class MyClass {
      myProp = 42;
    
      constructor() {
        console.log(this.myProp); // 42
      }
    }
    

    为了可读性的目的,对于那些在constructor里面已经定义的实例属性,新写法允许直接列出。

    class ReactCounter extends React.Component {
      state = {
        count: 0
      };
    }

    (2)类的静态属性:类的静态属性只要在上面的实例属性写法前面,加上static关键字就可以了。

    class MyClass {
      static myStaticProp = 42;
    
      constructor() {
        console.log(MyClass.myStaticProp); // 42
      }
    }

    9.new.target属性:

    new是从构造函数生成实例对象的命令。new.target属性一般用在构造函数之中,返回new命令作用于的那个构造函数。如果构造函数不是通过new命令调用的,new.target会返回undefined,因此这个属性可以用来确定构造函数是怎么调用的。

    function Person(name) {
      if (new.target !== undefined) {//new.target === Person
        this.name = name;
      } else {
        throw new Error('必须使用 new 命令生成实例');
      }
    }
    
    
    var person = new Person('张三'); // 正确
    var notAPerson = Person.call(person, '张三');  // 报错

    Class 内部调用new.target,返回当前 Class。子类继承父类时,new.target会返回子类。利用这个特点,可以写出不能独立使用、必须继承后才能使用的类。

    class Rectangle {
      constructor(length, width) {
        console.log(new.target === Rectangle);
        this.length = length;
        this.width = width;
      }
    }
    
    var obj = new Rectangle(3, 4); // 输出 true
    
    class Square extends Rectangle {
      constructor(length) {
        super(length, length);
      }
    }
    
    var obj1 = new Square(3); // 输出 false
    class Shape {
      constructor() {
        if (new.target === Shape) {
          throw new Error('本类不能实例化');
        }
      }
    }
    
    class Rectangle extends Shape {
      constructor(length, width) {
        super();
        // ...
      }
    }
    
    var x = new Shape();  // 报错 Uncaught Error: 本类不能实例化
    var y = new Rectangle(3, 4);  // 正确  Shape类不能被实例化,只能用于继承。注意,在函数外部,使用new.target会报错。

     

    展开全文
  • Class类简介

    万次阅读 2018-05-25 19:39:41
    1、Class类简介:  Java程序在运行时,Java运行时系统一直对所有的对象进行所谓的运行时类型标识。这项信息纪录了每个对象所属的类。虚拟机通常使用运行时类型信息选准正确方法去执行,用来保存这些类型...

    1、Class类简介:


     Java程序在运行时,Java运行时系统一直对所有的对象进行所谓的运行时类型标识。这项信息纪录了每个对象所属的类。虚拟机通常使用运行时类型信息选准正确方法去执行,用来保存这些类型信息的类是Class类。Class类封装一个对象和接口运行时的状态,当装载类时,Class类型的对象自动创建。
          Class 没有公共构造方法。Class 对象是在加载类时由Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的,因此不能显式地声明一个Class对象。 
          虚拟机为每种类型管理一个独一无二的Class对象。也就是说,每个类(型)都有一个Class对象。运行程序时,Java虚拟机(JVM)首先检查是否所要加载的类对应的Class对象是否已经加载。如果没有加载,JVM就会根据类名查找.class文件,并将其Class对象载入。
          基本的 Java 类型(boolean、byte、char、short、int、long、float 和 double)和关键字 void 也都对应一个 Class 对象。 
          每个数组属于被映射为 Class 对象的一个类,所有具有相同元素类型和维数的数组都共享该 Class 对象。
          一般某个类的Class对象被载入内存,它就用来创建这个类的所有对象。

    一、如何得到Class的对象呢?有三种方法可以的获取:

      1、调用Object类的getClass()方法来得到Class对象,这也是最常见的产生Class对象的方法。例如:
        MyObject x;
        Class c1 = x.getClass();

     2、使用Class类的中静态forName()方法获得与字符串对应的Class对象。例如: 
        Class c2=Class.forName(“MyObject”),Employee必须是接口或者类的名字。

    3、获取Class类型对象的第三个方法非常简单。如果T是一个Java类型,那么T.class就代表了匹配的类对象。例如
        Class cl1 = Manager.class;
        Class cl2 = int.class;
        Class cl3 = Double[].class;
        注意:Class对象实际上描述的只是类型,而这类型未必是类或者接口。例如上面的int.class是一个Class类型的对象。由于历史原因,数组类型的getName方法会返回奇怪的名字。

    二、Class类的常用方法

    1、getName() 

    一个Class对象描述了一个特定类的属性,Class类中最常用的方法getName以 String 的形式返回此 Class 对象所表示的实体(类、接口、数组类、基本类型或 void)名称。

    2、newInstance()

    Class还有一个有用的方法可以为类创建一个实例,这个方法叫做newInstance()。例如:
        x.getClass.newInstance(),创建了一个同x一样类型的新实例。newInstance()方法调用默认构造器(无参数构造器)初始化新建对象。

    3、getClassLoader() 

    返回该类的类加载器。

       4、getComponentType() 
        返回表示数组组件类型的 Class。

       5、getSuperclass() 
        返回表示此 Class 所表示的实体(类、接口、基本类型或 void)的超类的 Class。

       6、isArray() 
        判定此 Class 对象是否表示一个数组类。

    三、Class的一些使用技巧

    1、forName和newInstance结合起来使用,可以根据存储在字符串中的类名创建对象。例如
        Object obj = Class.forName(s).newInstance();

    2、虚拟机为每种类型管理一个独一无二的Class对象。因此可以使用==操作符来比较类对象。例如:
        if(e.getClass() == Employee.class)…

    2、 Class.forName()方法:


    Class.forName返回与给定的字符串名称相关联接口的Class对象。

    Class.forName是一个静态方法,同样可以用来加载类。该方法有两种形式:Class.forName(String name, boolean initialize, ClassLoader loader)和 Class.forName(String className)。第一种形式的参数 name表示的是类的全名;initialize表示是否初始化类;loader表示加载时使用的类加载器。第二种形式则相当于设置了参数 initialize的值为 true,loader的值为当前类的类加载器。

    static Class<?>

    forName(String className)

    Returns the Class object associated with the class or interface with the given string name.

    static Class<?>

    forName(String name, boolean initialize, ClassLoader loader)

    Returns the Class object associated with the class or interface with the given string name, using the given class loader.

    说明:

    publicstatic Class<?> forName(String className)

    Returns the Class object associated withthe class or interface with the given string name. Invokingthis method is equivalent to:

    Class.forName(className,true, currentLoader)

    where currentLoader denotes the definingclass loader of the current class.

    For example, thefollowing code fragment returns the runtime Class descriptor for theclass named java.lang.Thread:

    Class t =Class.forName("java.lang.Thread")

    A call to forName("X") causes theclass named X to beinitialized.

    Parameters:

    className - the fully qualifiedname of the desired class.

    Returns:

    the Class object for the classwith the specified name.

    从官方给出的API文档中可以看出:

    Class.forName(className)实际上是调用Class.forName(className,true, this.getClass().getClassLoader())。第二个参数,是指Class被loading后是不是必须被初始化。可以看出,使用Class.forName(className)加载类时则已初始化。

    所以Class.forName(className)可以简单的理解为:获得字符串参数中指定的类,并初始化该类

     

     一.首先你要明白在java里面任何class都要装载在虚拟机上才能运行。

    1.      forName这句话就是装载类用的(new是根据加载到内存中的类创建一个实例,要分清楚)。 

    2.      至于什么时候用,可以考虑一下这个问题,给你一个字符串变量,它代表一个类的包名和类名,你怎么实例化它?

               A a = (A)Class.forName(“pacage.A”).newInstance();这和 A a =new A();是一样的效果。

    3.      jvm在装载类时会执行类的静态代码段,要记住静态代码是和class绑定的,class装载成功就表示执行了你的静态代码了,而且以后不会再执行这段静态代码了。

    4.      Class.forName(xxx.xx.xx)的作用是要求JVM查找并加载指定的类,也就是说JVM会执行该类的静态代码段。

    5.      动态加载和创建Class 对象,比如想根据用户输入的字符串来创建对象

           String str = 用户输入的字符串  

           Class t = Class.forName(str);  

           t.newInstance(); 

     二.在初始化一个类,生成一个实例的时候,newInstance()方法和new关键字除了一个是方法,一个是关键字外,最主要有什么区别?

          1.它们的区别在于创建对象的方式不一样,前者是使用类加载机制,后者是创建一个新类。

          2.那么为什么会有两种创建对象方式?

            这主要考虑到软件的可伸缩、可扩展和可重用等软件设计思想。  
            Java中工厂模式经常使用newInstance()方法来创建对象,因此从为什么要使用工厂模式上可以找到具体答案。例如:

               class c = Class.forName(“Example”);  

               factory = (ExampleInterface)c.newInstance();  

           其中ExampleInterface是Example的接口,可以写成如下形式:

              String className = “Example”;  

              class c = Class.forName(className);  

              factory = (ExampleInterface)c.newInstance();  

          进一步可以写成如下形式:

              String className = readfromXMlConfig;//从xml 配置文件中获得字符串

             class c = Class.forName(className);  

             factory = (ExampleInterface)c.newInstance();  

            上面代码已经不存在Example的类名称,它的优点是,无论Example类怎么变化,上述代码不变,甚至可以更换Example的兄弟类Example2 , Example3 , Example4……,只要他们继承ExampleInterface就可以。  
            3.从JVM的角度看,我们使用关键字new创建一个类的时候,这个类可以没有被加载。  但是使用newInstance()方法的时候,

             就必须保证:

                  1、这个类已经加载;

                  2、这个类已经连接了。

            而完成上面两个步骤的正是Class的静态方法forName()所完成的,这个静态方法调用了启动类加载器,即加载 java API的那个加载器。  
             现在可以看出,newInstance()实际上是把new这个方式分解为两步,即首先调用Class加载方法加载某个类,然后实例化。这样分步的好处是显而易见的。我们可以在调用class的静态加载方法forName时获得更好

             的灵活性,提供给了一种降耦的手段。  

    三.最后用最简单的描述来区分new关键字和newInstance()方法的区别: 

    1. newInstance: 弱类型。低效率。只能调用无参构造。  
             2. new: 强类型。相对高效。能调用任何public构造。

    3、应用情景:


    情景一:加载数据库驱动的时候

    Class.forName的一个很常见的用法是在加载数据库驱动的时候。

    如:

    1. Class.forName(“com.microsoft.sqlserver.jdbc.SQLServerDriver”);  
    2. Connection con=DriverManager.getConnection(”jdbc:sqlserver://localhost:1433;DatabaseName==JSP”,“jph”,“jph”);      
    Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
    Connection con=DriverManager.getConnection("jdbc:sqlserver://localhost:1433;DatabaseName==JSP","jph","jph");    

      为什么在我们加载数据库驱动包的时候有的却没有调用newInstance( )方法呢?

    即有的jdbc连接数据库的写法里是Class.forName(xxx.xx.xx);而有一些:Class.forName(xxx.xx.xx).newInstance(),为什么会有这两种写法呢? 

    刚才提到,Class.forName(“”);的作用是要求JVM查找并加载指定的类,如果在类中有静态初始化器的话,JVM必然会执行该类的静态代码段。

    而在JDBC规范中明确要求这个Driver类必须向DriverManager注册自己,即任何一个JDBCDriver的Driver类的代码都必须类似如下: 
              public classMyJDBCDriver implements Driver {

        static{

           DriverManager.registerDriver(new MyJDBCDriver());

       }

       } 

      既然在静态初始化器的中已经进行了注册,所以我们在使用JDBC时只需要Class.forName(XXX.XXX);就可以了。

    情景二:使用AIDL与电话管理Servic进行通信

    Method method =Class.forName(“android.os.ServiceManager”)

             .getMethod(“getService”,String.class);

    // 获取远程TELEPHONY_SERVICEIBinder对象的代理

    IBinder binder =(IBinder) method.invoke(null, new Object[] { TELEPHONY_SERVICE});

    // IBinder对象的代理转换为ITelephony对象

    ITelephonytelephony = ITelephony.Stub.asInterface(binder);

    // 挂断电话

    telephony.endCall();


    参考资料:


    JDK1.8_API…/docs/api/java/lang/Class.html

    http://www.ibm.com/developerworks/cn/java/j-lo-classloader/

    展开全文
  • python中class的定义及使用

    万次阅读 多人点赞 2019-06-05 13:38:44
    #类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。 #对象:它是类的实例化。 #方法:类中定义的函数。 #类(Class) 由3个部分构成: ''' 类的名称:类名 类的属性...
    #类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。
    #对象:它是类的实例化。
    #方法:类中定义的函数。
    
    #类(Class) 由3个部分构成:
    '''
    类的名称:类名
    类的属性:指对象的特征(一组数据)
    类的方法:允许对象进行操作的方法 (行为/功能)
    '''
    
    # Python 3.x中取消了经典类,默认都是新式类。
    # 新式类的语法 -> class 类名(object): pass
    
    # 类对象支持两种操作:属性引用 和 实例化。
    # 属性引用的语法:obj.属性
    # 类实例化的语法:obj = 类名()
    # 类中方法的调用:obj.方法名()
    
    
    # 下面分析新式类的2种常见形式:
    
    #例1:
    #自定义一个类student
    class student(object):
        def speak(self):  ## 哪个对象调用了这个方法,self就是那个对象;可以把self理解为一个形参
            print("%s 说:我今年%s岁" % (self.name, self.age))
    
    #类student 实例化一个对象john
    john = student()
    # 给对象添加属性
    john.name = "约翰"
    john.age = 19
    # 调用类中的 speak()方法
    john.speak()
    #<<<约翰 说:我今年19岁
    
    
    #例2:
    class student(object):
        # 定义构造方法
        def __init__(self, n, a):  #__init__() 是类的初始化方法;它在类的实例化操作后 会自动调用,不需要手动调用;
            # 设置属性
            self.name = n
            self.age = a
        # 定义普通方法
        def speak(self):
            print("%s 说:我今年%s岁" % (self.name, self.age))
    
    #类student 实例化一个对象john
    john = student("约翰",19)
    
    # 调用类中的 speak()方法
    john.speak()
    #>>>约翰 说:我今年19岁
    
    # 在python中使用__开头 并以__结尾的方法,称之为魔法方法;
    # __init__(self) 是类的初始化方法,也称构造方法,是一种特殊的魔法方法。
    # __init__(self)在实例化后,会自动调用,而不用手动调用,所以一般把属性设置在_init__()里。
    # 常用到的魔法方法还有:__str__(self) 、 __del__(self)等。
    
    ## __str__(self)
    class student(object):
        # 定义构造方法
        def __init__(self, n, a):
            # 设置属性
            self.name = n
            self.age = a
            
        # 输出一个字符串(追踪对象属性信息变化)
        def __str__(self):  # __str__(self)不可以添加参数(形参)
            return "名字:%s 年龄:%d" % (self.name, self.age)
    
    # 实例化一个对象john
    john = student("约翰",19)
    
    # 当使用print输出对象时,只要自己定义了__str__(self)方法,那么就会打印从在这个方法中return的数据
    print(john)
    #>>>名字:约翰 年龄:19
    
    

     

    展开全文
  • C++类(Class)的定义与实现

    万次阅读 多人点赞 2018-08-01 17:41:17
    一、"类" 的介绍  在C++中, 用 "类" 来描述 "对象", 所谓的"对象"是指现实世界中的一切事物。那么类就可以看做是对相似事物的抽象, 找到这些不同事物间的共同点, 如自行车...

    一、"类" 的介绍
        在C++中, 用 "" 来描述 "对象", 所谓的"对象"是指现实世界中的一切事物。那么类就可以看做是对相似事物的抽象, 找到这些不同事物间的共同点, 如自行车和摩托车, 首先他们都属于"对象", 并且具有一定得相同点, 和一些不同点, 相同点如他们都有质量、都有两个轮子, 都是属于交通工具等。"都有质量"、"两个轮子"属于这个对象的属性, 而"都能够当做交通工具"属于该对象具有的行为, 也称方法。
        
        类是属于用户自定义的数据类型, 并且该类型的数据具有一定的行为能力, 也就是类中说描述的方法。通常来说, 一个类的定义包含两部分的内容, 一是该类的属性, 另一部分是它所拥有的方法。以 "人类" 这个类来说, 每个人都有自己的姓名、年龄、出生日期、体重等, 为 人类 的属性部分, 此外, 人能够吃饭、睡觉、行走、说话等属于人类所具有的行为。
        
        上面举例中所描述的 "人" 类仅仅是具有人这种对象的最基础的一些属性和行为, 可以称之为人的"基类"。 再说说一些具有一些职业的人, 例如学生, 一个学生还具有"基类"中所没有的属性, 如学校、班级、学号; 也可以具有基类所不具有的行为, 如每天需要去上课, 需要考试等。
        
        学生类可以看做是基类的一个扩展, 因为他具有基类的所有属性和行为, 并且在此基础上增加了一些基类所没有的属性和行为, 像"学生"这样的类称为"人类"这个基类的"派生类"或者"子类"。在学生的基础上海可以进一步的扩展出其他更高级的类, 如"研究生"类。
        
        到此, 我们不再更深的去介绍类的其他相关知识。
        
    二、C++类的定义

        C++中使用关键字 class 来定义类, 其基本形式如下:

    class 类名
    {
        public:
        //公共的行为或属性
    
        private:
        //公共的行为或属性
    };
    

    说明:
            ①. 类名 需要遵循一般的命名规则;
            
            ②. public 与 private 为属性/方法限制的关键字, private 表示该部分内容是私密的, 不能被外部所访问或调用, 只能被本类内部访问; 而 public 表示公开的属性和方法, 外界可以直接访问或者调用。
                一般来说类的属性成员都应设置为private, public只留给那些被外界用来调用的函数接口, 但这并非是强制规定, 可以根据需要进行调整;
                
            ③. 结束部分的分号不能省略。

    三、C++类的实现
        在上面的定义示例中我们只是定义了这个类的一些属性和方法声明, 并没有去实现它, 类的实现就是完成其方法的过程。类的实现有两种方式, 一种是在类定义时完成对成员函数的定义, 另一种是在类定义的外部进行完成。
        
        1>. 在类定义时定义成员函数
            成员函数的实现可以在类定义时同时完成, 如代码:

    #include <iostream>
    
    using namespace std;
    
    class Point
    
    {
    
        public:
    
        void setPoint(int x, int y) //实现setPoint函数
        
        {
    
            xPos = x;
    
            yPos = y;
    
        }
    
    
        void printPoint() //实现printPoint函数
    
        {
    
            cout<< "x = " << xPos << endl;
    
            cout<< "y = " << yPos << endl;
    
        }
    
    
        private:
        
           int xPos;
    
           int yPos;
    
    };
    
    
    int main()
    
    {
    
        Point M; //用定义好的类创建一个对象 点M
        
        M.setPoint(10, 20); //设置 M点 的x,y值
    
        M.printPoint(); //输出 M点 的信息
    
    
        return 0;
    
    }

    运行输出:

    x = 10 
    y = 20

    与类的定义相比, 在类内实现成员函数不再是在类内进行声明, 而是直接将函数进行定义, 在类中定义成员函数时, 编译器默认会争取将其定义为 inline 型函数 2>. 在类外定义成员函数
            在类外定义成员函数通过在类内进行声明, 然后在类外通过作用域操作符 :: 进行实现, 形式如下:

    返回类型 类名::成员函数名(参数列表)
    {
         //函数体
    }
    
    
    
    #include <iostream>
    
    using namespace std;
    
    class Point
    
    {
    
        public:
    
        void setPoint(int x, int y); //在类内对成员函数进行声明
    
        void printPoint();
    
    
        private:
    
        int xPos;
    
        int yPos;
    
    };
    
    void Point::setPoint(int x, int y) //通过作用域操作符 '::' 实现setPoint函数
    
    {
    
        xPos = x;
    
        yPos = y;
    
    }
    
    void Point::printPoint() //实现printPoint函数
    
    {
    
        cout<< "x = " << xPos << endl;
    
        cout<< "y = " << yPos << endl;
    
    }
    
    int main()
    
    {
    
        Point M; //用定义好的类创建一个对象 点M
    
        M.setPoint(10, 20); //设置 M点 的x,y值
    
        M.printPoint(); //输出 M点 的信息
    
    
        return 0;
    
    }

    依 setPoint 成员函数来说, 在类内声明的形式为 void setPoint(int x, int y); 那么在类外对其定义时函数头就应该是 void Point::setPoint(int x, int y) 这种形式, 其返回类型、成员函数名、参数列表都要与类内声明的形式一致。

    四、对象的作用域、可见域与生存周期
        类对象的作用域、可见域以及生存周期与普通变量的保持相同, 当对象生存周期结束时对象被自动撤销, 所占用的内存被回收, 需要注意的是, 如果对象的成员函数中有使用 new 或者 malloc 申请的动态内存程序不会对其进行释放, 需要我们手动进行清理, 否则会造成内存泄露。

    c++ 类的定义和使用

    #include "stdafx.h"
    #include <iostream>
    #include <string>
    using namespace std;
    class A
    {
    private:
        int n2;
        int n1;
    
    public:
    
        A() :n2(34), n1(n2+1) {}
    
        void Print() {
            cout << "n1:" << n1 << ", n2: " << n2 << endl;
        }
    };
    
    int main()
    {
        A a;
        a.Print();
        getchar();
        return 1;
    }

    这里写图片描述




    对上面代码稍微做调整: 将n1和n2两个变量定义的顺序互换一下


    #include "stdafx.h"
    #include <iostream>
    #include <string>
    using namespace std;
    class A
    {
    private:
        int n1;
        int n2;
    
    public:
    
        A() :n2(34), n1(n2+1) {}
    
        void Print() {
            cout << "n1:" << n1 << ", n2: " << n2 << endl;
        }
    };
    
    int main()
    {
    
        A a;
        a.Print();
    
        getchar();
        return 1;
    }

    打印结果:


    这里写图片描述




    由此可以总结: 构造函数中,变量初始化的顺序,是以变量定义的顺序来定的,而不是简单的以构造函数中变量出现的顺序来定的


    还可以使用有参的构造函数:


    #include "stdafx.h"
    #include <iostream>
    #include <string>
    using namespace std;
    class A
    {
    private:
        int n1;
        int n2;
    
    public:
    
        A(int k1,int k2) :n2(k1), n1(k2) {}
    
        void Print() {
            cout << "n1:" << n1 << ", n2: " << n2 << endl;
        }
    };
    
    int main()
    {
    
        A a(78,97);
        a.Print();
    
        getchar();
        return 1;
    }
    •  

    打印结果:


    这里写图片描述



    下面对上面进行改造一下:

    #include "stdafx.h"
    #include <iostream>
    #include <string>
    using namespace std;
    class A
    {
    private:
        int n1;
        int n2;
    
    public:
    
        A(int k1) :n2(k1), n1(n2) {}
    
        void Print() {
            cout << "n1:" << n1 << ", n2: " << n2 << endl;
        }
    };
    
    int main()
    {
    
        A a(115);
        a.Print();
    
        getchar();
        return 1;
    }

    打印结果: 
    这里写图片描述


    通过最后一个例子,再次证明,变量初始化的顺序是严格按照各个变量定义的先后顺序来的,而不是简单的依据各变量在构造函数中出现的先后顺序来定的



    下面两种写法是一个意思: 
    写法一:

    public:
        A(int k1,int k2) {
            n1 = k1;
            n2 = k2;
        }

    写法二:

    public:
    
        A(int k1,int k2) :n1(k1),n2(k2){}

     

    展开全文
  • class文件 某种意义上来说,java有两种对象:实例对象和Class对象。每个类的运行时的类型信息就是用Class对象表示的。它包含了与类有关的信息。其实我们的实例对象就通过Class对象来创建的。Java使用Class对象执行...
  • 关于Class<? extends T>

    千次阅读 2017-09-20 11:41:37
    首先先复习一下泛型的用途: 当我们将一个对象放入集合中,集合不会记住此对象的类型,当再次从集合中取出此对象时,改对象的编译类型变成了Object类型,但其运行时类型任然为其本身类型。 泛型,即“参数化类型”...
  • classClass的区别

    2020-07-19 03:30:28
    Class: classClass的关系类似于字符串与String类的关系,class创建的类是Class类的实例,Class类是对所有类的抽象和集合. Class类介绍 Class是一个位于Java.lang包里的类 private Class(ClassLoader loader, Class&...
  • 深入理解 Java 反射:Class (反射的入口)

    万次阅读 多人点赞 2017-01-18 19:58:14
    什么是 Reflection 反射,为什么要用它Java 强类型语言,但是我们在运行时有了解、修改信息的需求,包括类信息、成员信息以及数组信息。Java 中 Reflection 和 Introspection 区别?说起反射,还有一个相似的概念 ...
  • Java中Class对象详解

    万次阅读 多人点赞 2018-06-01 14:50:40
    从某种意义上来说,java有两种对象:实例对象和Class对象。每个类的运行时的类型信息就是用Class对象表示的。它包含了与类有关的信息。其实我们的实例对象就通过Class对象来创建的。Java使用Class对象执行其RT...
  • java经典代码片段

    千次阅读 2019-03-14 09:30:47
    java经典代码片段 写这篇也是用于学习 ... import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException;...import java.io.FileOutputStream;...import java.io.IO...
  • 1、错误描述 WARN:2015-05-01 13:26:10[localhost-startStop-1] - HHH000402: Using Hibernate built-in connection pool (not for production use!) WARN:2015-05-01 13:26:10[localhost-startStop-1] - Exception ...
  • 描述 我们修改接口时,习惯发布一个快照版本用于测试。我们的一个服务也是发布了快照版本,然后一个jar程序要依赖这个服务,修改pom文件打包部署后,通过 java -jar 命令执行这个jar程序,然后你懂的启动后报错了 ...
  • List<DivAppRecruitInfo> list2=(List) JSONArray.toList(JSONArray.fromObject(result), DivAppRecruitInfo.class); 我已经从服务端获取到json格式的字符串数据了,想要把json字符串转化成对象,需要使用...
  • root exception is java.rmi.MarshalException:error marshalling arguments:nested exception   今天写一个RMI的应用,气死人了,弄半天,跑到sun官网去一看,告诉我是一个BUG,我流出了鼻血。...
  • 使用软件IntelliJ IDEA在学习spring框架时,通过读取配置文件Properties并使用Class.forName()进行反射时报错:java.lang.ClassNotFoundException 解决方法: 1. class.forName(string); 参数string应该是 包名....
  • 相应的model对应的mapping中将resultType改成resultMap即可
  • 报这个错误绝对是因为大家粗心导致,不多说直接截图展示 图一 错误展示 图二 错误原因 在这里,注意上图标注黄色的部分,我们需要把resultType改为resultMap即可 这辈子坚持与不坚持都不可怕,怕的是独自走在...
  • 因为React Native 0.61版本以上是不需要手动link的,因此我就将原本项目里的需要link的组件使用命令 react-native unlink xxx 解绑,运行项目发现报错 Process: com.rnkey, PID: 2014 java.lang.RuntimeException...
  • Myeclipse工程中Class.forName加载mysql驱动异常解决
  • 添加jar包的classpath [color=red]export CLASSPATH=$CLASSPATH:/home/gushui/workspaces/newmyclusterworkspace/APCluster/dest/ap.jar[/color] 不用重启机器 对于一个job来说 [color=red]job.setJarByClass(.....

空空如也

1 2 3 4 5 ... 20
收藏数 9,767,042
精华内容 3,906,816
关键字:

class