精华内容
下载资源
问答
  • Python中创建和使用方法

    千次阅读 2019-03-13 06:56:31
    面向对象编程(OOP)是最有效的软件编写方法之一,我们会使用(CLASS)来定义出一大对象都有的行为,当我们基于创建对象时,每个对象都具备这种通用的行为。 然后根据需要赋予每个对象独特的个性。根据来...

     面向对象编程(OOP)是最有效的软件编写方法之一,我们会使用到类(CLASS)来定义出一大类对象都有的行为,当我们基于类来创建对象时,每个对象都具备这种通用的行为。

    然后根据需要赋予每个对象独特的个性。根据类来创建对象被称为实例化,你将把自己编写的类存储在模块中,并在自己的程序文件中导入其他程序员编写的类。


    1. 创建类


    简单来说我们定义的类应该包含两部分:属性+功能。

    我们来定义一个简单的计算器的类Calculator,

    class Calculator:#对于类的定义我们要求首字母大写
        name ='Good calculator'#固有属性项
        price =20
    
        def __init__(self,name,price,H,width=10,weight=5):#初始化类的属性
            self.name=name
            self.p=price
            self.h=H
            self.wi=width
            self.we=weight
    
        #定义内部函数,实现功能
        def add(self,x,y):#self 表示本类
            print(self.name)#在类中使用self调用它的名字
            result = x+y
            print(result)
    
        def minus(self,x,y):
            result = x-y
            print(result)
    
        def times(self,x,y):
            result = x*y
            print(result)
    
        def divide(self,x,y):
            result = x/y
            print(result)
    

     2.使用类

     根据上面创建的"Calculator"类, 定义一个外部实例"c"来调用类:

    c = Calculator('CC',20,30)#定义实例来使用该类
    #打印出实例中任何你想要的属性值
    #使用格式:class.name.属性
    
    print(c.name)#默认名称
    print(c.n)#实例中名称
    print(c.price)#默认的价格属性
    print(c.p)#实例中赋予的价格属性
    print(c.h)#实例中高度值
    print(c.we)#实例中宽度
    --------------------
    #结果输出如下:
    Good calculator
    CC
    20
    30
    40
    5

    注意:这里赋予属性的默认值是按照实际情况去设定,另外应该注意实例调用的时候默认属性的命名方式不同会导致复制结果的差异,这点和列表,字典都很类似。

     

    展开全文
  • 匿名内部的实现和使用例1(实现接口)例2(继承) 什么是匿名内部? 匿名内部,顾名思义,就是不知道这个到底是什么名字,也就是不知道类名。 匿名内部使用场景? 匿名内部适合创建那种只需要使用...

    什么是匿名内部类?

    匿名内部类,顾名思义,就是不知道这个类到底是什么名字,也就是不知道类名。

    匿名内部类的使用场景?

    匿名内部类适合创建那种只需要使用一次的类,也就是说创建一个匿名内部类,只需要用一次即可。

    匿名内部类如何创建?

    new 类名(参数) | 实现接口()
    {
    // 匿名内部类的类体部分
    }
    从上面的定义可以看出,匿名内部类必须继承一个父类,或实现一个接口,但最多只能继承一个父类,或者实现一个接口。
    两个规则:
    	匿名内部类不能是抽象类。
    	匿名内部类不能定义构造器。由于匿名内部类没有类名,所以无法定义构造器,但匿名内部类可以初始化块,可以通过初始化块来完成构造器需要完成的工作。
    

    匿名内部类的实现和使用

    例1(实现接口)

    首先,定义一个匿名类要实现的接口,代码如下

    public interface Product{
     double getPrice();
     String getName();
    

    然后,定义一个实体类,实体类定义一个方法,方法的参数为上述的接口对象,到时候会传入一个匿名类对象,这个匿名类实现了上述创建的接口,代码如下

    public class Anony{
    	public void test(Product product){
    	System.out.println("购买了一个"+product.getName()+",花掉了"+product.getPrice());
    	}
    }
    

    最后测试运行:

    pubic class Test{
    	public static void main(String[] args){
    		Anony anony=new Anony();
    		// 注意,此处要传入一个匿名类对象
    		anony.test(new Product(){
    			@Override
    			public double getPrice(){
    					return 578.6;
    				}
    			@Override
    			public String getName(){
    					return "联想笔记本";
    				}
    			}
    		);
    	}
    }
    

    输出:

    购买了一个联想笔记本,花掉了578.6
    

    总结:此处匿名内部类的作用就是实现了一个接口,创建了一个实现了该接口的类的对象,然后重写了这个接口中的方法。

    例2(继承类)

    首先,定义一个匿名类需要实现的抽象类,代码如下:

    public abstract class Device{
    	private String name;
    	public abstract double  getPrice();
    	public String getName(){
    	 	return name;
    	}
    	public Device(){}
    	public Device(String name){
    		this.name=name;
    	}
    } 
    

    然后,定义一个实体类,实体类定义一个方法,方法的参数为上述的抽象类对象,到时候会传入一个匿名类对象,这个匿名类继承了上述创建的抽象类,代码如下

    public class Anony {
    
        public void test(Device device){
            System.out.println("购买了一个"+device.getName()+"花费了"+device.getPrice());
        }
    }
    

    最后测试运行:

    pubic class Test{
    	public static void main(String[] args){
    		Anony anony=new Anony();
    		// 注意,此处要传入一个匿名类对象
    		anony.test(new Device("海尔电视机"){
    			@Override
    			public double getPrice(){
    					return 578.6;
    				}
    		);
    		Device device=new Device(){
    			@Override
    			public double getPrice(){
    				return 556.56;
    			}
    			@Override
    			public String getName(){
    				return "美的电视机";
    			}
    		};
    		annoy.test(device);
    	}
    }
    

    输出:

    购买了一个海尔电视机,花掉了578.6
    购买了一个美的电视机,花掉了556.56
    

    总结:对象匿名类中继承抽象类,对于抽象类里面的抽象方法,必须要重写,对象抽象类里面的非抽象方法,可重写也可以不重写。

    展开全文
  • Java创建对象详解:Java创建对象的几种方法

    万次阅读 多人点赞 2019-05-10 20:01:32
    Java 对象的生命周期包括创建使用和清除,本文详细介绍对象的创建,在 Java 语言中创建对象分显式创建与隐含创建两种情况。 显式创建对象 对象的显式创建方式有 4 种。 1. 使用 new 关键字创建对象 这是常用的创建...

    对象是对类的实例化。对象具有状态和行为,变量用来表明对象的状态,方法表明对象所具有的行为。Java 对象的生命周期包括创建、使用和清除,本文详细介绍对象的创建,在 Java 语言中创建对象分显式创建隐含创建两种情况。

    显式创建对象

    对象的显式创建方式有 4 种。

    1. 使用 new 关键字创建对象
    这是常用的创建对象的方法,语法格式如下:
    类名 对象名=new 类名();

    2. 调用 java.lang.Class 或者 java.lang.reflect.Constuctor 类的 newlnstance() 实例方法
    在 Java 中,可以使用 java.lang.Class 或者 java.lang.reflect.Constuctor 类的 newlnstance() 实例方法来创建对象,代码格式如下:
    java.lang.Class Class 类对象名称=java.lang.Class.forName(要实例化的类全称);
    类名 对象名=(类名)Class类对象名称.newInstance();

    调用 java.lang.Class 类中的 forName() 方法时,需要将要实例化的类的全称(比如 com.mxl.package.Student)作为参数传递过去,然后再调用 java.lang.Class 类对象的 newInstance() 方法创建对象。

    3. 调用对象的 clone() 方法
    该方法不常用,使用该方法创建对象时,要实例化的类必须继承 java.lang.Cloneable 接口。 调用对象的 clone() 方法创建对象的语法格式如下:
    类名对象名=(类名)已创建好的类对象名.clone();

    4. 调用 java.io.ObjectlnputStream 对象的 readObject() 方法

    下面创建一个示例演示常用的前三种对象创建方法。示例代码如下:

    public class Student implements Cloneable
    {   
        //实现 Cloneable 接口
        private String Name;    //学生名字
        private int age;    //学生年龄
        public Student(String name,int age)
        {    //构造方法
            this.Name=name;
            this.age=age;
        }
        public Student()
        {
            this.Name="name";
            this.age=0;
        }
        public String toString()
        {
            return"学生名字:"+Name+",年龄:"+age;
        }
        public static void main(String[] args)throws Exception
        {
            System.out.println("---------使用 new 关键字创建对象---------");
           
            //使用new关键字创建对象
            Student student1=new Student("小刘",22);
            System.out.println(student1);
            System.out.println("-----------调用 java.lang.Class 的 newInstance() 方法创建对象-----------");
           
            //调用 java.lang.Class 的 newInstance() 方法创建对象
            Class cl=Class.forName("Student");
            Student student2=(Student)cl.newInstance();
            System.out.println(student2);
            System.out.println("-------------------调用对象的 clone() 方法创建对象----------");
            //调用对象的 clone() 方法创建对象
            Student student3=(Student)student2.clone();
            System.out.println(student3);
        }
    }
    
    

    对上述示例的说明如下:

    使用 new 关键字或 Class 对象的 newInstance() 方法创建对象时,都会调用类的掏造方法。
    使用 Class 类的 newInstance() 方法创建对象时,会调用类的默认构造方法,即无参构造方法。
    使用 Object 类的 clone() 方法创建对象时,不会调用类的构造方法,它会创建一个复制的对象,这个对象和原来的对象具有不同的内存地址,但它们的属性值相同。
    如果类没有实现 Cloneable 接口,则 clone。方法会抛出 java.lang.CloneNotSupportedException 异常,所以应该让类实现 Cloneable 接口。

    程序执行结果如下:

    ---------使用 new 关键字创建对象---------
    学生名字:小刘,年龄:22
    -----------调用 java.lang.Class 的 newInstance() 方法创建对象-----------
    学生名字:name,年龄:0
    -------------------调用对象的done()方法创建对象----------
    学生名字:name,年龄:0
    

    隐含创建对象

    除了显式创建对象以外,在 Java 程序中还可以隐含地创建对象,例如下面几种情况。
    ①String strName=“strValue”,其中的“strValue”就是一个 String 对象,由 Java 虚拟机隐含地创建。
    ②字符串的“+”运算符运算的结果为一个新的 String 对象,示例如下:
    String str1=“Hello”;
    String str2=“Java”;
    String str3=str1+str2; //str3引用一个新的String对象
    ③当 Java 虚拟机加载一个类时,会隐含地创建描述这个类的 Class 实例。

    **提示:**类的加载是指把类的 .class 文件中的二进制数据读入内存中,把它存放在运行时数据区的方法区内,然后在堆区创建一个 java.lang.Class 对象,用来封装类在方法区内的数据结构。

    无论釆用哪种方式创建对象Java 虚拟机在创建一个对象时都包含以下步骤:

    1. 给对象分配内存。
    2. 将对象的实例变量自动初始化为其变量类型的默认值。
    3. 初始化对象,给实例变量赋予正确的初始值。

    注意: 每个对象都是相互独立的,在内存中占有独立的内存地址,并且每个对象都具有自己的生命周期,当一个对象的生命周期结束时,对象就变成了垃圾,由 Java 虚拟机自带的垃圾回收机制处理。

    展开全文
  • Python中创建使用实例

    千次阅读 2017-02-17 09:07:27
    #coding=utf8 #为了使除法总是会返回真实的商,不管操作数是整形还是...是面向对象编程的核心,它扮演相关数据及逻辑的容器角色。 定义语法: class ClassName(base_class[es]): "optional documentation string
    #coding=utf8 
    #为了使除法总是会返回真实的商,不管操作数是整形还是浮点型。
    from __future__ import division
    '''
    类是面向对象编程的核心,它扮演相关数据及逻辑的容器角色。
    定义类语法:
    class ClassName(base_class[es]):
              "optional documentation string"
              static_member_declarations
              method_declarations
    ----------------------------------------------------------------
    使用class关键字定义类。
    可以提供一个可选择的父类或者说基类。
    如果没有合适的基类,就默认使用object作为基类。
    class行之后是可选的文档字符串、静态成员定义、方法定义。
    '''
    class calculatorClass(object):
        '''first class:calculatorClass'''
        #定义一个静态变量来保存当前版本号
        version=1.0
        #设置输入参数并给参数赋值
        def __init__(self,one=10,two=20):
            self.first=one
            self.second=two
        
        '''加法'''
        def add(self):
            return self.first+self.second
        
        '''减法,取正数'''
        def sub(self):
            if self.first > self.second :
                return (self.first-self.second)
            else:
                return (self.second-self.first)
        
        '''乘法'''
        def mul(self):
            return self.first * self.second
            
        '''除法'''
        def div(self):
            if self.second !=0:
                return self.first/self.second
            else:
                pass
            
        '''取模'''
        def mod(self):
            if self.second !=0:
                return self.first%self.second
            else:
                pass
            
            
    '''
    上面类创建一个静态变量version,用例保存版本信息。
    __init__()是一个特殊方法当一个类实例被创建时,该方法会自动执行。
    该方法可以被当做构建函数,但它并不创建实例。
    它仅仅是对象创建后执行的第一个方法。
    它的目的是执行一些该对象的必要的初始化工作。
    '''
    
    '''创建一个计算机实例'''
    cal=calculatorClass(5,2)
    '''通过创建的实例,调用类中的方法和属性'''
    print "The current version:",cal.version
    print "----------------------------------"
    print "The two number add:",cal.add()
    print "The two number sub:",cal.sub()
    print "The two number mul:",cal.mul()
    print "The two number div:",cal.div()
    print "The two number mod:",cal.mod()      

    展开全文
  • Python中的的定义对象的创建

    万次阅读 多人点赞 2018-08-16 17:35:59
    面向对象中两个重要的概念: 1.类 :对一类事物的描述,是抽象的、概念上的定义。...1.创建类和创建类对象 1.创建类,类主要由类名,属性,方法组成,当然创建一个类时,属性和方法可以选择的。 cla...
  • linux创建文件

    万次阅读 多人点赞 2019-07-14 21:11:06
    在没有命令的情况下使用重定向符号时,它会创建一个文件。 但是它不允许你在创建文件时向其中输入任何文本。然而它对于不是很勤劳的管理员是非常简单有用的。只需要输入重定向符后面跟着你想要的文件名。 2、 在 ...
  • Java自定义数组的创建和使用

    万次阅读 2016-03-11 19:28:14
    简单介绍Java自定义数组的创建和使用,具体代码如下: 第一步:创建类 // 顶点表结点 private class VertexNode { char vertex; // 顶点域,存储顶点信息 VertexNode firstedge; // 边表头指针 } 第二步:...
  • js-ES6Class创建使用

    千次阅读 2018-12-18 17:44:47
    1.ES6提供了更接近传统语言的写法,引入了Class()这个概念,作为对象的模板。通过class关键字,可以定义。 2.//定义 class Point { constructor(x, y) { this.x = x; this.y = y; } toString() { ...
  • 文章目录1 内部的基本概念1.1 内部的定义1.2 内部的优缺点2 创建内部2.1 在外部外部创建非静态内部2.2 在外部外部创建静态内部2.3 在外部内部创建内部语法3 内部的分类3.1 成员内部3.2 静态...
  • 枚举创建使用

    万次阅读 2019-06-11 17:43:35
    一、枚举UnderwritingStatusEnum.java的创建 public enum UnderwritingStatusEnum { 核保状态_未提交核保("0"), 核保状态_标准件("1"), 核保状态_非标件("2"), 核保状态_拒保可申诉("3"), ...
  • Xcode 7将创建类别/扩展/协议文件的操作均归类为Create “Objective-C File”
  • 在react开发过程中,有时会碰到一些...接下来我们就来看看函数组件和类组件都是如何去挂载创建ref和使用它的: 函数式组件(Hook): // 首先引入React及useRef import React, { useRef } from 'react; function Con...
  • 1:定义一个矩形Rectangle:(知识点:对象的创建和使用) 定义三个方法:getArea()求面积、getPer()求周长,showAll()分别在控制台输出长、宽、面积、周长。 有2个属性:长length、宽width 通过构造方法...
  • java中链表的创建和使用

    万次阅读 多人点赞 2019-06-10 12:25:34
    链表的创建和使用 1,创建一个链表: a,定义一个class ListNode 如下: //创建一个链表的 class ListNode{ int val; //数值 data ListNode next; // 结点 node ListNode(int x){ //可以定义一个有参构造...
  • python之创建类的两种方法

    千次阅读 2018-08-22 19:33:21
    创建类第一种普遍方式可能都清楚,用class关键字: #第一种方法创建类 class A(object): def __init__(self, name): self.name = name f = A("lkk") 这样就简单完成了一个A创建,我们尝试打印...
  • Python中type的使用和的理解

    万次阅读 多人点赞 2018-09-06 14:46:15
    “元就是深度的魔法,99%的用户应该根本不必为此操心。如果你想搞清楚究竟是否需要用到元,那么你就不需要它。那些实际用到元的人都非常清楚地知道他们需要做什么,而且根本不需要解释为什么要用元。” ...
  • IntelliJ IDEA 快捷键 创建测试

    万次阅读 2018-04-07 16:05:47
    IntelliJ IDEA中用快捷键自动创建测试的默认按键为: ctrl+shift+t –> create new test 菜单位置: 使用快捷键或者点击菜单后: 会出现如下界面: 勾选需要测试的方法,点击OK。 个人微信...
  • Java中如何创建一个枚举Enum

    千次阅读 2019-12-10 15:22:21
    从jdk5出现了枚举后,定义一些字典值可以使用枚举类型。 枚举常用的方法是 values():对枚举中的常量值进行遍历; valueof(String name) :根据名称获取枚举中定义的常量值;要求字符串跟枚举的常量名必须一致...
  • 按照图片找到对应的位置写上对应的代码即可 @Data @NoArgsConstructor 有需要的也可以加上作者,时间等注解 /** * @author ran * @date ${DATE} ${TIME} * @version 1.0.0 */ ok!
  • Python的定义和使用

    万次阅读 多人点赞 2019-03-06 10:35:18
    一般,使用 class 语句来创建一个新,class之后为的名称(通常首字母大写)并以冒号结尾,例如: class Ticket(): def __init__(self,checi,fstation,tstation,fdate,ftime,ttime): self.checi=checi self.fstat...
  • 创建自定义异常

    万次阅读 2018-05-25 09:55:17
    创建自定义的异常需要继承自Exception,并提供含有一个String类型形参的构造方法,该形参就是一场的描述信息,可以通过getMessage()方法获得。例如: public class NewException extends Exception{ public ...
  • JAVA“”数组的创建与调用

    千次阅读 2017-07-16 19:57:25
    JAVA“”数组的创建与调用C++相比是不同的。先看这样一个数组的创建注:bookFeature 是一个错误1:class bookList { private int bookNum=0; final int MAXSIZE=1001; public bookList(){ bookNum=0; ...
  • java.io.File代表系统文件名(路径文件名) (1)File常见的构造方法: //以pathname为路径创建File对象,如果pathname是相对路径则默认当前路径在系统属性user.dir中存储 public File(String pathname) { ...
  • java007如何java创建一个

    万次阅读 2019-04-16 20:22:37
    二,如何在java中创建一个?定义属性,方法,以及实例化一个对象并调用里面的内容? 方法:1:无进无出:没有返回值,没有参数传 2:无进有出:没有返回值,有参数 3:有进无出:有返...
  • 在开发过程中,经常需要保留开发人员的姓名开发时间,那么在创建一个时,让他自动显示姓名时间,这样很方便。 首先打开IDEA,打开file->settings(或使用快捷键CTRL + ALT + s) 找到Editor->File and ...
  • LabVIEW中的属性-创建及读写

    千次阅读 2016-09-21 21:38:11
    通过属性节点来访问LabVIEW的的数据成员。
  • Java创建一个学生

    万次阅读 多人点赞 2019-07-06 20:37:46
    创建一个表示学生的实体 Student,其中有学生姓名、性别年龄信息。要求使用属性来表示学生信息,最终编写测试代码。 首先定义一个名为 Student 的,代码如下: public class Student { //学生 } 在...
  • 创建模型(在数据库中生成这个User表)3.1创建连接引擎3.2创建(第1种方法:创建指定的模型)3.3创建(第2种方法:创建所有继承Base的模型)4.完整代码总览 1.导包并创建Base from sqlalchemy.ext....
  • IDEA创建类时添加注释 已有的补充注释
  • JAVA创建抽象

    千次阅读 2017-11-11 12:58:44
    二、抽象使用原则 (1)抽象方法必须为public或者protected(因为如果为private,则不能被子继承,子类便无法实现该方法),缺省情况下默认为public;  (2)抽象不能直接实例化,需要依靠子类采

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,964,246
精华内容 1,585,698
关键字:

如何创建和使用类