精华内容
下载资源
问答
  • 看到这个问题第一反应是不懂,然后查询了网上的一些说法,感觉略有不一。...然后,多个线程访问这个的两个方法也有不同的形式,例如访问这个的两个方法是通过同一个类的实例对象来访问还是通过不同...

    看到这个问题第一反应是不懂,然后查询了网上的一些说法,感觉略有不一。细看之下发现大家对这个问题的分析角度不太一样,就会出现不同的结果,在这里记一下我收集来的不同的角度和自己的例子,感觉这个题目还是蛮有意思的。

    首先,同步锁有两种,JVM的synchronized和JDK的ReentrantLock;
    然后,多个线程访问这个类的两个方法也有不同的形式,例如访问这个类的两个方法是通过同一个类的实例对象来访问还是通过不同的类的实例对象访问;
    再者,一个类的两个方法加了同步锁,这两个被同步方法也没有说明是什么样的方法。他可能是类的普通实例方法,也可能是类中Runnable对象的run方法。

    看到这里也许会觉得我对于问题过于的咬文嚼字,但是我想要探讨更多的可能,不同的情形有着不同的结果,而且这些不同的情形能开拓思路,让我们看问题能多个角度,也可以帮我加深多线程的理解。如果本文中有错误或者不恰当的例子,或者代码写的不严谨不规范风格不好,都可以留言提出。

    一.synchronized

    1.多个线程同时访问同一个类实例对象的两个同步方法:

    package synchronizedTest;
    
    public class Example1 {
    	private int num = 0 ;
    	(省略getter.setter,后同)
    	public synchronized void method1() {
    		System.out.println("同步方法1进入");
    		for(int i = 0 ; i<10 ; i++) {
    			System.out.print("同步方法1:"+num+"--");
    			num++ ;
    		}
    		System.out.println("同步方法1结束");
    	}
    	
    	public synchronized void method2() {
    		System.out.println("method2进入:");
    		for(int i = 0 ; i<10 ; i++) {
    			System.out.print("method2:"+num+"--");
    			num++ ;
    		}
    		System.out.println("method2结束");
    	}
    	
    	public static void main(String[] args) {
    		final Example1 example1 = new Example1() ;
    		
    		Thread thread1 = new Thread(new Runnable() {
    			@Override
    			public void run() {
    				example1.method1();
    			}
    		}) ;
    		
    		Thread thread2 = new Thread(new Runnable() {
    			@Override
    			public void run() {
    				example1.method2();
    			}
    		}) ;
    		try {
    			thread2.join();
    			thread1.join();			
    			thread1.start();
    			thread2.start();
    		} catch (InterruptedException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}		
    	}
    	
    }
    

    输出结果:

    method1进入
    同步方法1:0--同步方法1:1--同步方法1:2--同步方法1:3--同步方法1:4--同步方法1:5--同步方法1:6--同步方法1:7--同步方法1:8--同步方法1:9--method1结束
    method2进入:
    method2:10--method2:11--method2:12--method2:13--method2:14--method2:15--method2:16--method2:17--method2:18--method2:19--method2结束
    

    显然此时多个线程是不能访问同个类(的一个实例对象)的两个同步方法的

    2.多个线程同时访问同一个类的不同实例对象的两个同步方法:
    将上面的代码稍作修改,主函数中多new一个该类实例

    final Example1 example2 = new Example1() ;
    

    再修改thread2的run方法调用的类实例为example2

    Thread thread2 = new Thread(new Runnable() {
    			@Override
    			public void run() {
    				example2.method2();
    			}
    		}) ;
    

    得到结果:

    同步方法1进入
    method2进入:
    method2:0--method2:1--同步方法1:0--同步方法1:1--同步方法1:2--method2:2--同步方法1:3--method2:3--同步方法1:4--method2:4--同步方法1:5--method2:5--同步方法1:6--同步方法1:7--method2:6--同步方法1:8--同步方法1:9--method2:7--同步方法1结束
    method2:8--method2:9--method2结束
    

    这时候显然,多个线程是能访问同个类(的不同实例对象)的两个同步方法的。

    小结:这是因为synchronized是对象锁,即线程获得的锁是施加在一个实例对象上的,如果不同的线程访问的是同一对象上的不同的同步方法,那么显然不能同时进行。
    如果是不同对象上的不同的同步方法,那么就是可以同时进行的。

    3.多个线程同时访问同一个类实例对象的两个Runnable对象的run方法:

    package synchronizedTest;
    
    public class Example2 {
    	private int num ;
    	public Runnable runnable1 = new Runnable() {
    		@Override
    		public void run() {
    			//同步锁
    			synchronized (this) {
    				System.out.println("线程1进入");
    				for(int i = 0 ; i < 10 ; i ++) {
    					System.out.print("线程1:"+num+"--");
    				}
    				System.out.println("线程1结束");
    			}
    		}
    	};
    	
    	public Runnable runnable2 = new Runnable() {
    		@Override
    		public void run() {
    			//同步锁
    			synchronized (this) {
    				System.out.println("thread2进入");
    				for(int i = 0 ; i < 10 ; i ++) {
    					System.out.print("thread2:"+num+"--");
    				}
    				System.out.println("thread2结束");
    			}
    		}
    	};
    	
    	public static void main(String[] args) {
    		Example2 example = new Example2() ; //创建一个对象
    		new Thread(example.runnable1).start(); //同步方法1
    		new Thread(example.runnable2).start(); //同步方法2
    	}
    }
    
    

    输出结果:

    thread2进入
    线程1进入
    thread2:0--线程1:0--线程1:0--thread2:0--线程1:0--线程1:0--线程1:0--thread2:0--线程1:0--thread2:0--thread2:0--线程1:0--thread2:0--线程1:0--thread2:0--thread2:0--线程1:0--thread2:0--线程1:0--thread2:0--线程1结束
    thread2结束
    

    可见此时多个线程是能同时访问同个类的两个同步方法的。这是因为
    synchronized(this){ //... }中锁住的不是代码块,即这个锁在run方法中,但是并不是同步了这个run方法,而是括号中的对象this,也就是说,多个线程会拿到各自的锁,就能够同时执行run方法。(在run方法前声明synchronized也是同样的效果)

    new Thread(example.runnable1).start(); //同步方法1
    new Thread(example.runnable2).start(); //同步方法2
    

    打印出这个this对象,是两个不同的类实例对象:

    synchronizedTest.Example2$1@65db6dfa
    synchronizedTest.Example2$2@471fab
    

    也说明了不同线程的实例对象不同,都是各自对象的锁,不可以认为是类似于例子1中的同一实例对象,而应该类似与例子2的不同类的实例对象

    总结:分析synchronized同步锁的核心在于他是个对象锁,找清楚锁的对象

    二.ReentrantLock锁
    1.多个线程同时访问同一个类实例对象的两个同步方法:
    将例子1的synchronized改为引入ReentrantLock

    package ReentrantLockTest;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class LockExample {
    	private int num;
    	private Lock lock = new ReentrantLock();
    
    	public void method1() {
    			lock.lock();
    			System.out.println("同步方法1进入");
    			for(int i = 0 ; i<10 ; i++) {
    				System.out.print("同步方法1:"+num+"--");
    				num++ ;
    			}
    			System.out.println("同步方法1结束");
    			lock.unlock();
    	}
    
    	public void method2() {
    		lock.lock();
    		System.out.println("method2进入:");
    		for (int i = 0; i < 10; i++) {
    			System.out.print("method2:" + num + "--");
    			num++;
    		}
    		System.out.println("method2结束");
    		lock.unlock();
    	}
    
    	public static void main(String[] args) {
    		final LockExample example = new LockExample() ;
    		Thread thread1 = new Thread(new Runnable() {
    			@Override
    			public void run() {
    				example.method1();
    			}
    		}) ;
    		
    		Thread thread2 = new Thread(new Runnable() {
    			@Override
    			public void run() {
    				example.method2();
    			}
    		}) ;
    		
    		try {
    			thread2.join();
    			thread1.join();
    			thread1.start();
    			thread2.start();
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}
    }
    
    

    输出结果:

    同步方法1进入
    同步方法1:0--同步方法1:1--同步方法1:2--同步方法1:3--同步方法1:4--同步方法1:5--同步方法1:6--同步方法1:7--同步方法1:8--同步方法1:9--同步方法1结束
    method2进入:
    method2:10--method2:11--method2:12--method2:13--method2:14--method2:15--method2:16--method2:17--method2:18--method2:19--method2结束
    

    可见此时多个线程是不能访问同个类(的一个实例对象)的两个同步方法的

    2.多个线程同时访问同一个类的不同实例对象的两个同步方法:
    修改main函数的即可:

    public static void main(String[] args) {
    		final LockExample example1 = new LockExample() ;//两个实例
    		final LockExample example2 = new LockExample() ;
    		Thread thread1 = new Thread(new Runnable() {
    			@Override
    			public void run() {
    				example1.method1(); //实例1的同步方法1
    			}
    		}) ;
    		
    		Thread thread2 = new Thread(new Runnable() {
    			@Override
    			public void run() {
    				example2.method2();//实例2的同步方法2
    			}
    		}) ;
    		
    		try {
    			thread2.join();
    			thread1.join();
    			thread1.start();
    			thread2.start();
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}
    

    输出结果:

    同步方法1进入
    method2进入:
    同步方法1:0--method2:0--method2:1--同步方法1:1--method2:2--同步方法1:2--同步方法1:3--method2:3--同步方法1:4--method2:4--同步方法1:5--同步方法1:6--method2:5--同步方法1:7--method2:6--同步方法1:8--同步方法1:9--同步方法1结束
    method2:7--method2:8--method2:9--method2结束
    
    

    可见,多个线程是能访问同个类(的不同实例对象)的两个同步方法的。

    总结:ReentrantLock和synchronized的前两个例子结论都相同

    3.多个线程同时访问同一个类实例对象的两个Runnable对象的run方法:

    package ReentrantLockTest;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class Lockexample2 {
    
    	private int num;
    	private Lock lock = new ReentrantLock();
    	
    	public Runnable runnable1 = new Runnable() {
    		@Override
    		public void run() {
    			lock.lock();//上锁
    			System.out.println("线程1进入");
    			for(int i = 0 ; i < 10 ; i ++) {
    				System.out.print("线程1:"+num+"--");				
    			}
    			System.out.println("线程1结束");
    			lock.unlock();
    		}
    	};
    	
    	public Runnable runnable2 = new Runnable() {
    		@Override
    		public void run() {
    			lock.lock();//上锁
    			System.out.println("thread2进入");
    			for(int i = 0 ; i < 10 ; i ++) {
    				System.out.print("thread2:"+num+"--");
    			}
    			System.out.println("thread2结束");
    			lock.unlock();
    		}
    	};
    	
    	public static void main(String[] args) {
    		Lockexample2 example = new Lockexample2();
    		new Thread(example.runnable1).start(); 
    		new Thread(example.runnable2).start(); 
    		
    	}
    }
    
    

    输出结果:

    线程1进入
    线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1结束
    thread2进入
    thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2结束
    
    

    这里可以看到,与synchronized的第三个例子出现了不同的结果。在这个地方,ReentrantLock不允许多线程同时访问一个类的不同同步方法。
    这里要注意的是ReentrantLock与synchronized不同,ReentrantLock的实现方式是要先创建ReentrantLock对象,然后用这个对象的方法来上锁。而一个类的实例中只有一个ReentrantLock对象:

    private Lock lock = new ReentrantLock();
    

    而本例中,线程的创建是建立在同一个类实例上的:

    Lockexample2 example = new Lockexample2();
    new Thread(example.runnable1).start(); 
    new Thread(example.runnable2).start(); 
    

    因此,ReentrantLock对象lock是同一个,因此第一个线程进入同步方法1后就获取了锁,第二个线程无法获取这个锁,只能等待。

    如果换成是两个实例对象:

    public static void main(String[] args) {
    		Lockexample2 example = new Lockexample2();
    		Lockexample2 example2 = new Lockexample2();
    		new Thread(example.runnable1).start(); 
    		new Thread(example2.runnable2).start(); 
    		
    	}
    

    输出结果

    线程1进入
    thread2进入
    线程1:0--线程1:0--线程1:0--线程1:0--thread2:0--线程1:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--线程1:0--thread2:0--线程1:0--线程1:0--thread2:0--线程1:0--thread2结束
    线程1:0--线程1结束
    
    

    可见不同的实例对象中是不同的ReentrantLock对象,因此可以同时访问

    小结:ReentrantLock锁的核心在与ReentrantLock对象是不是同一个

    三.结论
    重新看看这个问题:一个类中的两个方法都加了同步锁,多个线程能同时访问这个类的两个方法吗?

    现在应该比较清楚了,这个问题要分成synchronized和ReentrantLock两个情况:

    一.对于synchronized
    1.一个类中的两个方法都加了同步锁,多个线程不能同时访问这个类的同一实例对象的两个方法
    2.一个类中的两个方法都加了同步锁,多个线程同时访问这个类的不同实例对象的两个方法
    3.一个类中的两个方法**(Runnable的run方法)都加了同步锁,多个线程能**同时访问这个类的两个方法(不论是不是同一实例对象)

    二.对于ReentrantLock
    1.一个类中的两个方法都加了同步锁,多个线程不能同时访问这个类的同一实例对象的两个方法(不论同步加在实例方法中或是run方法中)
    2.一个类中的两个方法都加了同步锁,多个线程同时访问这个类的不同实例对象的两个方法(不论同步加在实例方法中或是run方法中)

    展开全文
  • 类中三类方法

    千次阅读 2018-05-02 16:48:43
    类中三类方法 类中三类方法:普通、静态(static)、常方法(const) static: 静态成员变量必须要在类外进行初始化; 属于但不属于对象,所以,计算大小时,不算static成员变量大小; 所有对象共用...

    类中的三类方法

    类中的三类方法:普通、静态(static)、常方法(const)

    static:

    • 静态成员变量必须要在类外进行初始化;
    • 属于类但不属于对象,所以,计算类大小时,不算static成员变量大小;
    • 所有对象共用一个变量时使用static声明的变量;
    • static 成员方法没有this指针,直接用类的作用域调用;
    • static成员方法与变量在类外定义均不用加staic,但要加类作用域;
    • 普通成员方法可调用静态成员方法,static变量
    • static方法不能访问普通成员变量/方法(同一对象中的),只能访问其他static成员。

    const

    • 常方法可访问不可修改
    • const对象无法调用普通成员方法

      问题1:static和const能共存吗?
      不能,static是把this指针没了,而const是给this指针加const,这两者是矛盾的。
      问题2:常对象为什么不能调普通方法?
      默认情况下,this指针是指向非常量版本的常量指针。我们不能把this绑定到一个常量对象上(即int *const 绑定到 int const)这样也就使我们不能在一个常量对象上调用普通成员函数。

    mutable(突破const限制)

    主要用于后来扩充时,从前写的常方法增加需求。(不过尽量还是不要使用)
    三种方法使用注意:
    - 普通成员方法可调用静态成员方法,static变量
    - static方法不能访问普通成员变量/方法(同一对象中的),只能访问其他static成员。
    - const对象无法调用普通成员方法
    即普通方法都可调用(优先调普通),static只可调用同一对象static,const只可调const

    展开全文
  • 在一个类中可能出现三种方法,实例方法、静态方法类方法,下面来看看三种方法的不同: 1、实例方法 实例方法的第一个参数必须是”self”,实例方法只能通过实例进行调用,这时候“self”就代表这个实例...

    在一个类中,可能出现三种方法,实例方法、静态方法和类方法,下面来看看三种方法的不同:

    1、实例方法

    • 实例方法的第一个参数必须是”self”,实例方法只能通过类实例进行调用,这时候“self”就代表这个类实例本身通过”self”可以直接访问实例的属性
    class person(object):
        tall = 180
        hobbies = []
        def __init__(self, name, age,weight):
            self.name = name
            self.age = age
            self.weight = weight
        def infoma(self):
            print('%s is %s weights %s'%(self.name,self.age,self.weight))
    
    
    Bruce = person("Bruce", 25,180)
    Bruce.infoma()

    输出:

    Bruce is 25 weights 180

    2、类方法

    • 类方法以cls作为第一个参数cls表示类本身,定义时使用@classmethod装饰器。通过cls可以访问类的相关属性。
    class person(object):
    
        tall = 180
        hobbies = []
        def __init__(self, name, age,weight):
            self.name = name
            self.age = age
            self.weight = weight
        @classmethod     #类的装饰器
        def infoma(cls):   #cls表示类本身,使用类参数cls
            print(cls.__name__)
            print(dir(cls))
    #cls表示类本身
    #person.infoma()  直接调用类的装饰器函数,通过cls可以访问类的相关属性
    Bruce = person("Bruce", 25,180)   #也可以通过两步骤来实现,第一步实例化person,第二步调用装饰器
    Bruce.infoma() 

    代码的输出为,从这段代码可以看到,类方法可以通过类名访问,也可以通过实例访问

    person
    ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'hobbies', 'infoma', 'tall']
    person
    ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'hobbies', 'infoma', 'tall']

    3、静态方法

    • 与实例方法和类方法不同,静态方法没有参数限制,既不需要实例参数,也不需要类参数,定义的时候使用@staticmethod装饰器。
    • 同类方法一样,静态法可以通过类名访问,也可以通过实例访问。
    class person(object):
    
        tall = 180
        hobbies = []
        def __init__(self, name, age,weight):
            self.name = name
            self.age = age
            self.weight = weight
        @staticmethod    #静态方法装饰器
        def infoma():     #没有参数限制,既不要实例参数,也不用类参数
            print(person.tall)
            print(person.hobbies)
    #person.infoma()   #静态法可以通过类名访问
    Bruce = person("Bruce", 25,180)   #通过实例访问
    Bruce.infoma() 

    这三种方法的主要区别在于参数,实例方法被绑定到一个实例,只能通过实例进行调用;但是对于静态方法和类方法,可以通过类名和实例两种方式进行调用。

    展开全文
  • python里会出现这三个单词,self和cls都可以用别的单词代替,方法三种, 一是通过def定义的 普通的一般的,需要至少传递一个参数,一般用self,这样的方法必须通过一个类的实例去访问,类似于c++通过对象...

    python类里会出现这三个单词,self和cls都可以用别的单词代替,类的方法有三种,

    一是通过def定义的 普通的一般的,需要至少传递一个参数,一般用self,这样的方法必须通过一个类的实例去访问,类似于c++中通过对象去访问;

    二是在def前面加上@classmethod,这种类方法的一个特点就是可以通过类名去调用,但是也必须传递一个参数,一般用cls表示class,表示可以通过类直接调用;

    三是在def前面加上@staticmethod,这种类方法是静态的类方法,类似于c++的静态函数,他的一个特点是参数可以为空,同样支持类名和对象两种调用方式;

    展开全文
  • COM组件有三个最基本的接口,分别是IUnknown、IClassFactory、IDispatch。 COM规范规定任何组件、任何接口都必须从IUnknown继承,IUnknown包含三个函数,分别是 QueryInterface、AddRef、Release。这三个函数是...
  • 4.第单元任务实训:编写一个类ExceptionTest,main方法中使用try-catch-finally语句结构实现:try语句块,编写两个数相除操作,相除的两个操作数要求程序运行时用户输入;catch语句块,捕获被0除所...
  • 3个只出现一次的数字,他们的bit位肯定不可能全部相同,也就是说,虽然有些bit位上的数可能相等,但肯定至少存在某一个bit位,这个数,有两个数的该bit位为1,一个数的该bit位为0,或者两个数的该bit位
  • Java方法详解

    万次阅读 2019-10-18 18:31:50
    方法详解控制成员函数的访问向方法传递对象返回对象方法重载重载构造函数递归static关键字static代码块嵌套和内部varargs(可变长度实参) 控制成员函数的访问 Java的访问控制符有三个: public:...
  • 基于SVM的中文文本分类方法

    千次阅读 2017-06-15 16:50:21
    基于SVM的中文文本分类方法 1、文本分类简介 文本分类(Text Classification)是将文本文档与规定好的类别进行匹配的过程。文本分类可以分为训练和分类两阶段,其对应的流程图如下面的图1.1和图1.2所示: 图...
  • 同步容器和并发容器

    万次阅读 多人点赞 2019-07-31 19:22:20
    Java的集合容器框架,主要有四大类别:List、Set、Queue、Map。 注意Collection和Map是顶层接口,而List、Set、Queue接口则分别继承了Collection接口,分别代表数组、集合和队列这容器。 像ArrayList、...
  • 设计一个只能创建一个唯一实例的——单例模式 1. 背景  老师布置了一个思考题:设计一个只能创建一个唯一实例的。让我们只要想一下思路即可。自己的第一反应就是设计模式的单例模式。自己百度了一下单例...
  • 使用Android studio编译项目时,出现第方依赖的库找不...如果多依赖库出现上述这种情况,可能出现的原因是,整个项目目录结构下的gradle.properties文件进行了如下图的类似设置 注销类似的代码,就可以了
  • 聊使用事务时(@Transactional)可能出现的问题

    千次阅读 多人点赞 2020-08-20 08:11:31
    介绍了使用Spring事务中可能碰到的各种问题。例如事务失效、事务回滚异常、读写分离下事务如何处理等
  • 怎样从一个DLL导出一个C++

    万次阅读 2008-10-08 16:58:00
    一个用户能以下面三种方式调用 Xyz 的功能: 使用纯 C 使用一个规则的 C++ 使用一个抽象的 C++ 接口 源码(译注:文章附带的源码)包含两个工程: XyzLibrary – 一个 DLL 工程 ...
  • 文本分类的降维方法总结

    万次阅读 2017-08-18 11:16:11
    人们通常采用向量空间模型来描述文本向量,但是如果直接用分词算法和词频统计方法得到的特征项来表示文本向量的各个维,那么这向量的维度将是非常的大。 这种未经处理的文本矢量不仅给后续工作带来巨大的计算...
  • 定义一个完整的类方法,需要六个步骤,也就是六大部分。也因为这六个部分的不同而可以大概分为9种方法。 这是我一整天作图整理出来的。可能有些漏缺错误,希望大家能帮忙纠正。让我明白哪里错了,这是对我这个初学者...
  • 前言Spring Cloud,Feign和Ribbon整合了Hystrix后,可能出现首次调用失败的问题,要如何解决该问题呢?造成该问题的原因Hystrix默认的超时时间是1秒,如果超过这时间尚未响应,将会进入fallback代码。而...
  • 主要有三类不同的学习方法:监督学习(Supervised learning)、非监督学习(Unsupervised learning)、半监督学习(Semi-supervised learning)。 监督学习:通过已有的一部分输入数据与输出数据之间的相应关系。生成一个...
  • 题目:一个int数组个数字a、b、c只出现一次,其他数字都出现了两次。请找出个只出现一次的数字。 上篇博文我们求的是两个只出现一次的数字,且时间复杂度为O(n),这次是个,可以同样考虑将数组先分成两...
  • verilog代码避免出现latch方法

    千次阅读 2018-01-11 10:50:11
    组合逻辑,有时候往往不需要生成latch,所以必须知道某些信号会综合为latch,通过实践发现下面两出现latch: 1.if-else和case没有else和default将会导致产生latch。这个在夏宇闻的verilog有讲到。 ...
  • 早期的图像处理是随由于通讯方面的要求而发展起来的,随着图像处理技术的发展,数字图像处理技术与理论已经成为计算机应用的一个重要领域,广泛应用于众多的科学与工程应用,如遥感、医学、气象、通信等。...
  • 1.创建并启动线程的6方式: 1)继承Thread创建线程 2)实现Runnable接口创建线程 ...6)定时器Timer (底层封装了一个TimerThread对象) 1.1 继承Thread创建线程 1.1.1继承Thread方式创建线程的...
  • Java类中,我们可以通过“import + 包名 + 类名”的方式引用第方包(jar)或者第(class),但你得告诉Java编译和运行环境到哪里去找这些库或者,如果这些没有设置好,就会出现类似于某某无法解析,...
  • 网络层—IP地址的三种分类方式

    千次阅读 2015-12-01 17:09:57
    IP地址是给因特网上的每一个主机或者是路由器的每一个接口(注意是接口,而不是主机或者是路由器本身)分配的一个在全世界范围唯一的32位的标识符。IP地址是由ICANN(Internet Corporation for Assigned Names and...
  • 当你创建一个子类的实例时,首先会调用父类的构造函数,然后再调用子类的构造函数,如果父类没有缺省构造函数,则必须再子类的构造函数显示的调用它(如下面的例子),程序的顺序是这样的: super(...) /...
  • ArcGIS 的标准分类方法

    万次阅读 2015-04-03 14:44:49
    例如,如果为取值范围为 0-300 的字段指定三个类,ArcGIS 将创建三个类,其取值范围分别为 0–100、101–200 和 201–300。 相等间隔最适用于常见的数据范围,如百分比和温度。这种方法强调的是某个属性值相对于...
  • Java的包装

    千次阅读 多人点赞 2019-04-16 15:34:10
    、包装类中的缓存机制 四、包装的四则运算、位运算、比较运算、逻辑运算 五、包装作为方法的形参、返回值 六、包装作为集合的元素 七、包装使用过程可能引起的空指针异常 八、为什么需要包装?...
  • 的继承(三种继承方式)

    千次阅读 2018-07-05 22:30:35
    时候,派生继承了基类的公有部分和保护部分,并且继承的这一些数据成员以私有部分存在于派生类中。基类的私有继承无法访问。2,派生保护继承于基类。这时候,派生继承了基类的公有部分和保护部分,并且...
  • 统计学第一类错误和第二错误

    万次阅读 2015-11-22 11:03:14
    统计学存在两错误这两错误主要是统计学假设检验出现的,因此,先要了解假设检验的基本概念。 假设检验(Hypothesis Testing)是数理统计学根据一定假设条件由样本推断总体的一种方法。具体作法是:根据...
  • Java和对象 详解(

    万次阅读 多人点赞 2016-10-06 20:48:02
    、面向对象简述面向对象是一种现在最为流行的程序设计方法,几乎现在的所有应用都以面向对象为主了,最早的面向对象的概念实际上是由IBM提出的,70年代的Smaltalk语言之进行了应用,后来根据面向对象的设计...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,102,019
精华内容 440,807
关键字:

在一个类中可能出现三种方法