精华内容
下载资源
问答
  • 如果用了staticmethod,那么就可以无视这个self,而将这个方法当成一个普通的函数使用。而对于classmethod,它的第一个参数不是self,是cls,它表示这个类本身。例子:#coding:utf-8classFoo(object):"""类三种方法...

    d9b8c784a02628b6512bb18c1afce15c.png

    python 类语法中有三种方法,实例方法,静态方法,类方法。

    普通实例方法,第一个参数需要是self,它表示一个具体的实例本身。

    如果用了staticmethod,那么就可以无视这个self,而将这个方法当成一个普通的函数使用。

    而对于classmethod,它的第一个参数不是self,是cls,它表示这个类本身。

    例子:# coding:utf-8

    class Foo(object):

    """类三种方法语法形式"""

    def instance_method(self):

    print("是类{}的实例方法,只能被实例对象调用".format(Foo))

    @staticmethod

    def static_method():

    print("是静态方法")

    @classmethod

    def class_method(cls):

    print("是类方法")

    foo = Foo()

    foo.instance_method()

    foo.static_method()

    foo.class_method()

    print('----------------')

    Foo.static_method()

    Foo.class_method()

    运行结果如下:是类的实例方法,只能被实例对象调用

    是静态方法

    是类方法

    ----------------

    是静态方法

    是类方法

    说明:

    实例方法只能被实例对象调用,静态方法(由@staticmethod装饰的方法)、类方法(由@classmethod装饰的方法),可以被类或类的实例对象调用。

    实例方法,第一个参数必须要默认传实例对象,一般习惯用self。

    静态方法,参数没有要求。

    类方法,第一个参数必须要默认传类,一般习惯用cls。

    展开全文
  • 一个.java文件中可以有很多类。不过注意以下点:1、public 权限的类...)3、若这个文件中没有public的类,则文件名随便是一个类的名字即可4、用javac 编译这个.java文件的时候,它会给每一个类生成一个.class文件...
    一个.java文件中可以有很多类。不过注意以下几点:
    1、public 权限的类只能有一个(也可以一个都没有,但最多只有1个)
    2、这个.java文件的文件名必须是public类的类名(一般的情况下,这里放置main方法是程序的入口。)
    3、若这个文件中没有public的类,则文件名随便是一个类的名字即可
    4、用javac 编译这个.java文件的时候,它会给每一个类生成一个.class文件
    展开全文
  • 1.创建并启动线程的6种方式: 1)继承Thread创建线程 2)实现Runnable接口创建线程 ...6)定时器Timer (底层封装了一个TimerThread对象) 1.1 继承Thread创建线程 1.1.1继承Thread方式创建线程的...

    1.创建并启动线程的6种方式:

    1)继承Thread类创建线程
    2)实现Runnable接口创建线程
    3)使用Callable和FutureTask创建线程
    4)使用线程池,例如用Executor框架
    5)Spring实现多线程(底层是线程池)
    6)定时器Timer (底层封装了一个TimerThread对象)

    1.1 继承Thread类创建线程
    1.1.1继承Thread类方式创建线程的实现步骤:

    步骤:
    1):定义一个类A继承于java.lang.Thread类.
    2):在A类中覆盖Thread类中的run方法.
    3):我们在run方法中编写需要执行的操作---->run方法里的,线程执行体.
    4):在main方法(线程)中,创建线程对象,并启动线程.
    创建线程类对象: A类 a = new A类();
    调用线程对象的start方法: a.start();//启动一个线程

    注意:千万不要调用run方法,如果调用run方法好比是对象调用方法,依然还是只有一个线程,并没有开启新的线程.

    1.1.2需求:使用两个线程实现边听歌边打游戏

    实现代码:

    //音乐线程
    public class MusicThread {
    public static void main(String[] args) {
    //创建游戏线程对象
    GameThread game = new GameThread();
    //启动游戏线程
    game.start();
    while(true){
    System.out.println(Thread.currentThread().getName()+"听音乐!");
    }
    }
    }
    //游戏线程
    class GameThread extends Thread{
    @Override
    public void run() {
    while (true) {
    System.out.println(Thread.currentThread().getName()+"打游戏!");
    }
    }
    }
    

    注意:有的小伙伴可能觉得音乐线程没有启动,在这里其实音乐线程已经启动起来了,而启动音乐线程的对象就是我们的JVM,此处main方法其实启动的时候会创建一个主线程去执行main方法,所以我在这里使用主线程作为了我的音乐线程.

    1.2 实现Runnable接口创建线程
    1.2.1实现Runnable接口方式创建线程的实现步骤:

    1):定义一个类A实现于java.lang.Runnable接口,注意A类不是线程类.
    2):在A类中覆盖Runnable接口中的run方法.
    3):我们在run方法中编写需要执行的操作---->run方法里的,线程执行体.
    4):在main方法(线程)中,创建线程对象,并启动线程.
    创建线程类对象: Thread t = new Thread(new A());
    调用线程对象的start方法: t.start();

    1.2.2需求:使用两个线程实现边听歌边打游戏

    实现代码:

    //音乐线程
    public class MusicThread {
    public static void main(String[] args) {
    //创建游戏线程对象
    Thread game = new Thread(new Game());
    //启动游戏线程
    game.start();
    while(true){
    System.out.println(Thread.currentThread().getName()+"听音乐!");
    }
    }
    }
    
    
    //游戏
    class Game implements Runnable{
    @Override
    public void run() {
    while (true) {
    System.out.println(Thread.currentThread().getName()+"打游戏!");
    }
    }
    }
    
    1.2.3 继承方式和实现方式的区别

    1)继承方式是一个类继承了Thread后成为线程类的子类,实现方式是一个类实现Runnable接口,但是这个类不是线程类,因为该类没有start等方法.
    2)启动的时候继承方式直接调用自己的start方法,实现方式是借助了Thread中的start方法启动的,自身没有start方法
    3)继承方式调用的run方法是通过方法覆盖,通过继承方式实现的,运行的时候先找子类,没有最后才运行父类的run方法.实现方式是执行Thread的run方法,而Thread中的run方法调用了实现类中的run方法,使用过组合关系的方法调用实现的.

    1.3实现 Callable 接口
    1.3.1使用Callable和FutureTask创建线程的实现步骤:

    1)定义一个Callable接口的实现类
    2)创建Callable实现类对象传递给FutureTask构造器
    3)将FutureTask对象传递给Thread构造器
    4)Thread对象调用start方法启动线程
    5)通过FutureTask对象的get方法获取线程运行的结果

    注意:
    Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果,该方法会阻塞直到任务返回结果。
    使用场景:使用多线程计算结果并返回该结果。

    1.3.2需求:使用2个线程异步计算1-1000,000内之和

    实现代码:

    public class CallableDemo {
    public static void main(String[] args) throws Exception  {
    //1.创建并启动线程
    Callable<Integer> call1 = new CallableImpl(0, 50000);
    Callable<Integer> call2 = new CallableImpl(50001, 100000);
    
    
    FutureTask<Integer> f1 = new FutureTask<>(call1);
    FutureTask<Integer> f2 = new FutureTask<>(call2);
    
    
    new Thread(f1).start();
    new Thread(f2).start();
    //2.获取每一个线程的结果
    int ret1 = f1.get();
    int ret2 = f2.get();
    int ret= ret1+ret2;
    System.out.println(ret);
    }
    }
    class CallableImpl implements Callable<Integer>{
    
    
    private int min;
    private int max;
    
    
    public CallableImpl(int min, int max) {
    this.min = min;
    this.max = max;
    }
    
    
    @Override
    public Integer call() throws Exception {
    int sum = 0;
    for (int i = min; i <= max; i++) {
    sum+=i;
    }
    return sum;
    }
    }
    
    1.3.3Callable和Runnable的区别如下:

    1)Callable定义的方法是call,而Runnable定义的方法是run。
    2)Callable的call方法可以有返回值,而Runnable的run方法不能有返回值。
    3)Callable的call方法可抛出异常,而Runnable的run方法不能抛出异常。

    注意:
    FutureTask为Runnable的实现类
    FutureTask可以视为一个闭锁(门闩),因为只有当线程运行完才会出现结果。

    1.4使用线程池(Executor框架【后面详细讲解Executor框架】)

    线程池,顾名思义就是一个池子里面放了很多的线程,我们用就将线程从里面拿出来,使用完毕就放回去池子中。设计和数据库连接池相似,存在静态工厂方法用于创建各种线程池。
    操作步骤:
    1)使用Executors工具类中的静态工厂方法用于创建线程池
    newFixedThreadPool:创建可重用且固定线程数的线程池,
    newScheduledThreadPool:创建一个可延迟执行或定期执行的线程池
    newCachedThreadPool:创建可缓存的线程池
    2)使用execute方法启动线程
    3)使用shutdown方法等待提交的任务执行完成并后关闭线程。
    代码演示如下:

    public class Demo4 {
        public static void main(String[] args) {
            Executor executor = Executors.newFixedThreadPool(5);
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
            ((ExecutorService) executor).shutdown();
        }
    }
    
    1.5 Spring实现多线程

    在Spring3之后,Spring引入了对多线程的支持,如果你使用的版本在3.1以前,应该还是需要通过传统的方式来实现多线程的。从Spring3同时也是新增了Java的配置方式,而且Java配置方式也逐渐成为主流的Spring的配置方式。

    代码演示如下:

    导入的包:

    <dependencies>
         <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter</artifactId>
              <version>2.1.0.RELEASE</version>
         </dependency>
    </dependencies>
    

    配置类:

    @Configuration
    @ComponentScan("cn.wolfcode")
    @EnableAsync //允许使用异步任务
    public class SpringConfig {}
    

    服务类:

    @Service
    public class SpringService {
        @Async // 这里进行标注为异步任务,在执行此方法的时候,会单独开启线程来执行
        public void dowork1() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "-->" + i);
            }
        }
        @Async
        public void dowork2() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "-->" + i);
            }
        }
    }
    

    测试类:

    public class SpringThreadDemo {
        public static void main(String[] args) {
            AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
            SpringService bean = context.getBean(SpringService.class);
            bean.dowork1();
            bean.dowork2();
        }
    }
    

    在这里插入图片描述
    在这里DEBUG信息不是什么错误,不会影响代码的正常运行,其实可以不用管的,但是为什么出现这个问题呢?

    Spring的定时任务调度器会通过BeanFactory.getBean的方法来尝试获取一个注册过的TaskExecutor对象来做任务调度,获取不到TaskExecutor对象再尝试找ScheduledExecutorService 对象,都找不到就报DEBUG信息。报错之后就找自己本身默认的scheduler定时器对象,这个举动其实是做一个提醒作用,所以如果没有强迫症可以不用管它。

    1.5.1解决Spring使用多线程的报错信息

    强迫症患者想要解决怎么办,三种方式:
    1.在log4j文件中加入log4j.logger.org.springframework.scheduling = INFO(治标不治本)
    2.在本配置文件或者配置类中设置一个bean
    3.配置类实现AsyncConfigurer接口并覆盖其getAsyncExecutor方法

    1.6 定时器

    严格来说定时器(Timer)不是线程,他只是调度线程的一种工具,它里面封装了一个线程,所以我们可以使用定时器来使用线程。
    在这里插入图片描述
    在这里插入图片描述
    操作步骤:
    1)创建Timer 对象
    2)调用schedule方法
    3)传入TimerTask子类对象

    代码演示如下:

    Timer timer = new Timer();
    timer.schedule(new TimerTask() {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "-->" + i);
            }
    
    
        }
    }, 100, 100);
    
    展开全文
  • 一个.java文件中可以有很多类。不过注意以下点:1、public 权限的类只能...)3、若这个文件中没有public的类,则文件名随便是一个类的名字即可4、用javac 编译这个.java文件的时候,它会给每一个类生成一个.class文件
    一个.java文件中可以有很多类。不过注意以下几点:
    1、public 权限的类只能有一个(也可以一个都没有,但最多只有1个)
    2、这个.java文件的文件名必须是public类的类名(一般的情况下,这里放置main方法是程序的入口。)
    3、若这个文件中没有public的类,则文件名随便是一个类的名字即可
    4、用javac 编译这个.java文件的时候,它会给每一个类生成一个.class文件
    展开全文
  • 继承Thread new Thread( piblic void run(){  } ).start(); b.实现Runnable接口 new Thread(new Runnable(){ public void run(){    } } ).start();注意:启动线程是start方法!...
  • 两种实现方法,分别是继承Thread与实现Runnable接口package ThreadDemo;public class Thread1 { private int j; public Thread1(int j) { this.j = j; } private synchronized void inc()
  • 一个java文件可以有个类嘛?

    千次阅读 2017-04-17 12:09:45
    一个.java文件中可以有很多。不过注意以下点: 1、public 权限的只能有一个(也可以一个都没有,但最多只有1个) 2、这个.java文件的文件名必须是public的类名(一般的情况下,这里放置main方法是程序的...
  • java多线程实现方法主要3种:继承Thread、实现Runnable接口和使用ExecutorService、callable、future实现返回结果的多线程。...start()方法是一种native方法,它将启动一个新线程并执行run方法。这种方法
  • 创建并启动线程的6种方式 继承Thread类创建线程 实现Runnable接口创建线程 使用Callable和FutureTask创建线程 使用线程池,例如用Executor框架 Spring实现多线程(底层是线程池) ...1) 定义一个类A继承...
  • 一个.java文件中可以有很多类。不过注意以下点:1、public 权限的类只能有一个(也可以一个都没有...则文件名随便是一个类的名字即可4、用javac 编译这个.java文件的时候,它会给每一个类生成一个.class文件像这样 //
  • 本文作者:黄海燕,叩丁狼高级讲师。原创文章,转载请注明出处。 ##1.创建并启动线程的6种方式: 1)继承Thread创建线程 2)实现Runnable接口创建...6)定时器Timer (底层封装了一个TimerThread对象) ##...
  • 当A想要实现一个接口中个别方法是(不是所有方法),可以创建一个抽象去实现该接口,然后在A去继承这个抽象。注意:这个抽象必须重写这个接口的所有方法,A可以实现其中的个别方法;如果抽象没有...
  • 这是我写的一段代码,package对应的是包名,class对应的是类名,那main方法中写的那些东西算是什么呢,没有一个具体的名称来描述,比如for循环,当初学的时候成为流程控制,但是我觉得这个名很怪,方法中的那些...
  • 一个类都对应一个Class类。得到对应Class类的方法有以下种 1 调用类的.class取得 2 调用类的getClass()方法 3 用Class.forName()方法取得 4 对于原生数据类型,可以用.TYPE取得 ...
  • 1. Java中有几方法可以实现一个线程?? 两种,分别是继承thread和实现Runnable接口。 第一种: new Thread(){}.start();这表示调用Thread子类对象的run方法,new Thread(){}表示一个Thread的匿名子类的实例...
  • java5以前,两种实现方法,分别使用new Thread()和new Thread(runnable)形式,第种继承Thread,直接调用thread的run方法,所以,我们往往使用Thread子类,即new SubThread()。第二种是实现Runnable接口,调用...
  • 60 、 java 中有几方法可以实现一个线程?用什么关键字修饰同步方法 ? stop() 和 suspend() 方 法为何不推荐使用? 答: 有两种实现方法,分别是继承 Thread与实现Runnable接口 分别使用 new Thread()和 new ...
  • ----------------------------------------String类是java封装的对字符串操作的一个类很多有用的好的方法,下面自己来实现两个,java做的,我们其实都可以自己做到。接下来,写两个方法,实现String 中的trim()...
  • 1 从被加载到虚拟机内存中开始,到卸载出内存为止,它的整个生命周期包括:加载...另外注意这里的几个阶段是按顺序开始,而不是按顺序进行或完成,因为这些阶段通常都是互相交叉地混合进行的,通常在一个阶段执行的过
  • 需要把一串二进制代码从一部手机上通过短信(如:0x01 0x08 0x00 0x34 0x55)发送到另外一个号码,是不是用sendDataMessage方法?里面几个参数的意义是什么? 没有哪位大哥能给个范例,小弟不胜感激。 在线等。 ...
  • String str = Class.forName(String).newInstance() <br />两种方法创建的对象实体没有任何区别,如果硬说区别的话,那就是第种直接调用了本的构造函数,如果本类有构造函数重载的话,可以添加...
  • 目录django的中间件最多可以几个方法?使用中间件做什么?csrf中间件的使用方法为什么使用csrf中间件如何使用?view视图里面是直接写方法,如何使用csrf?view视图里面写,如何使用csrf? django的中间件最多...
  • 以下方法家长和老师可以通用,不同的是:家长毁一个,老师毁一群,效率更高。  首先应该做的是摧毁孩子的自尊,将孩子贬到卑微的地位上。  具体方法有这样条:  1、让孩子觉得自己什么都...
  • 两种实现方法,分别是继承Thread与实现Runnable接口用synchronized关键字修饰同步方法反对使用stop(),是因为它不安全。它会解除由线程获取的所有锁定,而且如果对象处于种不连贯状态,那么其他线程能在那种...
  • 第 2 点也可以看做一个破坏封装性的缺点了。所以这样做是比较少见的,仅在定义一些数据结构的时候会这样用。比如像你举的例子中,如果是数据,里面主要以属性为主,方法较少,且它们的联系很紧密,这样用就会方便...
  • 01每日题抽象类与接口类的区别?大家对抽象类与接口类肯定不陌生,那么你能说出它们之间的点区别?主要有以下9点区别:1、默认的方法实现。抽象类可以有默认的方法实现完...
  • 1.refreshVisuals方法 默认情况下,方法 refreshVisuals() 仅在 EditPart 初始化的过程中调用一次,并且决不会被再次调用。...为改进性能,您可能希望将每个模型属性的代码分解成其自己的方法(或者是一个
  • 但是这个操作速度极慢.(因为此函数是能确保插入结果,所以每一次操作都是一个事物) 两种办法提高插入效率: 1> 使用 ".bulkInsert()" 可以一次插入多个. 2> ".applyBatch();" 也可以一次插入多个.
  • 有些时候,我们要求一个程序在系统中只能启动一个实例。...在设计模式中,就有一个SINGLETON模式,该模式就是让只有一个实例。(关于SINGLETON模式,可以看我那篇《重读《设计模式》之学习笔记(三)--S

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,893
精华内容 3,557
关键字:

一个类可以有几个方法