THE TWENTY-FIRST DAY

最新推荐文章于 2020-07-15 19:09:31 发布

aizaiee

最新推荐文章于 2020-07-15 19:09:31 发布

阅读量187

点赞数 1

分类专栏：培训日记

本文链接：https://blog.csdn.net/aizaiee/article/details/79750566

版权

培训日记专栏收录该内容

49 篇文章 0 订阅

订阅专栏

今天星期三，参加培训的第二十一天，依旧是早起，然后吃饭到教室开始看书，今天问了一下舍友，applet果然是没怎么有人用了，还好吧，反正就是很让我纠结就对了。

没什么别的好说的，objectinputstream 读空文件会产生EOF什么的异常，然后通过捕捉异常来进行操作就好了，

其它的也没有什么讲的了，直接上代码了：

先来今天查的知识：

1、final,finally,finalize的区别：
final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，
不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。
将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明
时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。

finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的
catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。

finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做
必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。
它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源
或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

2：HashMap和Hashtable的区别：
两个类的继承体系有些不同。虽然都实现了Map、Cloneable、Serializable三个接口。但是HashMap继承自抽象类AbstractMap，而HashTable继承自抽象类Dictionary。其中Dictionary类是一个已经被废弃的类，这一点我们可以从它代码的注释中看
HashTable比HashMap多了两个公开方法。一个是elements，这来自于抽象类Dictionary，鉴于该类已经废弃，所以这个方法也就没什么用处了。另一个多出来的方法是contains，这个多出来的方法也没什么用，因为它跟containsValue方法功能是一样的
HashMap是支持null键和null值的，而HashTable在遇到null时，会抛出NullPointerException异常。这并不是因为HashTable有什么特殊的实现层面的原因导致不能支持null键和null值，这仅仅是因为HashMap在实现时对null做了特殊处理，将null的hashCode值定为了0，从而将其存放在哈希表的第0个bucket中
简单来说就是，如果你不需要线程安全，那么使用HashMap，如果需要线程安全，那么使用ConcurrentHashMap。HashTable已经被淘汰了，不要在新的代码中再使用它。

3、sleep()和wait()的区别：
这两个方法来自不同的类分别是Thread和Object
最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法(锁代码块和方法锁)。
wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用(使用范围)
sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常
sleep方法属于Thread类中方法，表示让一个线程进入睡眠状态，等待一定的时间之后，自动醒来进入到可运行状态，不会马上进入运行状态，因为线程调度机制恢复线程的运行也需要时间，一个线程对象调用了sleep方法之后，并不会释放他所持有的所有对象锁，所以也就不会影响其他进程对象的运行。但在sleep的过程中过程中有可能被其他对象调用它的interrupt(),产生InterruptedException异常，如果你的程序不捕获这个异常，线程就会异常终止，进入TERMINATED状态，如果你的程序捕获了这个异常，那么程序就会继续执行catch语句块(可能还有finally语句块)以及以后的代码。
注意sleep()方法是一个静态方法，也就是说他只对当前对象有效，通过t.sleep()让t对象进入sleep，这样的做法是错误的，它只会是使当前线程被sleep 而不是t线程
wait属于Object的成员方法，一旦一个对象调用了wait方法，必须要采用notify()和notifyAll()方法唤醒该进程;如果线程拥有某个或某些对象的同步锁，那么在调用了wait()后，这个线程就会释放它持有的所有同步资源，而不限于这个被调用了wait()方法的对象。wait()方法也同样会在wait的过程中有可能被其他对象调用interrupt()方法而产生

4、&和&&的区别：

&和&&都可以用作逻辑运算符，表示逻辑与。当运算符两边的表达式都为true时，结果才为true；否则，结果为false。
另外&&还具有短路功能，也就是说，当&&左边的表达式结果为false时，将不再运算&&右边的表达式，结果肯定为false。例如，对于if(str!=null&&!str.equals(“”)),当str为null时，不会对&&右边的表达式进行运算，否则会出现空指针异常。
&还可以用作位运算符，当&两边的表达式不是boolean类型时，&表示按位与

5、用最有效率的方法算出2*8等于几：
2<<3

6、"=="和equals的区别：
==：
== 比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象。比较的是真正意义上的指针操作。

1、比较的是操作符两端的操作数是否是同一个对象。
2、两边的操作数必须是同一类型的（可以是父子类之间）才能编译通过。
3、比较的是地址，如果是具体的阿拉伯数字的比较，值相等则为true，如：
int a=10 与 long b=10L 与 double c=10.0都是相同的（为true），因为他们都指向地址为10的堆。
equals：
　　equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的equals方法返回的却是==的判断。
　　String s="abce"是一种非常特殊的形式,和new 有本质的区别。它是java中唯一不需要new 就可以产生对象的途径。以String s="abce";形式赋值在java中叫直接量,它是在常量池中而不是象new一样放在压缩堆中。这种形式的字符串，在JVM内部发生字符串拘留，即当声明这样的一个字符串后，JVM会在常量池中先查找有有没有一个值为"abcd"的对象,如果有,就会把它赋给当前引用.即原来那个引用和现在这个引用指点向了同一对象,如果没有,则在常量池中新创建一个"abcd",下一次如果有String s1 = "abcd";又会将s1指向"abcd"这个对象,即以这形式声明的字符串,只要值相等,任何多个引用都指向同一对象.
　　而String s = new String("abcd");和其它任何对象一样.每调用一次就产生一个对象，只要它们调用。
　　也可以这么理解: String str = "hello"; 先在内存中找是不是有"hello"这个对象,如果有，就让str指向那个"hello".如果内存里没有"hello"，就创建一个新的对象保存"hello". String str=new String ("hello") 就是不管内存里是不是已经有"hello"这个对象，都新建一个对象保存"hello"。

7、不能从一个static方法的内部发出对非static方法的访问、调用。

8、overload和override的区别：overload的方法可以改变返回值的类型，但不可以通过改变返回值类型来进行overload:;overrride的返回类型必须一致

摘要：重载Overload表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同（即参数个数或类型不同）
Overload是重载的意思，Override是覆盖的意思，也就是重写。
重载Overload表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同（即参数个数或类型不同）。
重写Override表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中的定义方法，这相当于把父类中定义的那个完全相同的方法给覆盖了，这也是面向对象编程的多态性的一种表现。子类覆盖父类的方法时，只能比父类抛出更少的异常，或者是抛出父类抛出的异常的子异常，因为子类可以解决父类的一些问题，不能比父类有更多的问题。子类方法的访问权限只能比父类的更大，不能更小。如果父类的方法是private类型，那么，子类则不存在覆盖的限制，相当于子类中增加了一个全新的方法。

9、接口可以继承接口，抽象类可以实现接口。

另外今天学的线程：

经典知识： synchronized:

package am;

public class SynchronizedTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
     s2();
	}
	public static void  s1() {
		  RunableTest rt1= new RunableTest();
	      RunableTest rt2 = new RunableTest();
	      RunableTest rt3=new RunableTest();
	      Thread thread1= new Thread(rt1,"rt1thread1");
	      Thread thread2 = new Thread(rt1,"rt1thread2");
	      thread1.start();
	      thread2.start();
	}
	public static void s2() {
		Clerk clerk = new Clerk();
		Producter producter = new Producter(clerk);
		Customer customer = new Customer(clerk);
		Thread thread1 = new Thread(producter);
		Thread thread2 = new Thread(customer);
		thread1.start();
		thread2.start();
	}
	private static class Clerk{
		static int productNums = 0;
		static int allProductNums=0;
		static int allGetProductNums=0;
		public synchronized void addProduct() {
			if(productNums>=20) {
				try {
					wait();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			} else {
				allProductNums++;
				productNums=productNums+1;
//				System.out.println(Thread.currentThread().getName()+" :"+productNums);
				notifyAll();
			}
		}
		
		public synchronized void getProduct() {
			if(productNums<1) {
				try {
					wait();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			} else {
				allGetProductNums++;
				productNums=productNums-1;
//				System.out.println(Thread.currentThread().getName()+" :"+productNums);
				notifyAll();
			}
		}
	}
	private static class Producter implements Runnable{
		private Clerk clerk;
		public Producter(Clerk clerk) {
			this.clerk=clerk;
		}
		@Override
		public void run() {
			// TODO Auto-generated method stub
			while(true) {
			try {
				Thread.sleep(500);
				clerk.addProduct();
				System.out.println("生产者生产了第"+clerk.allProductNums+"个产品");
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			}
		}
	}
	
	private static class Customer implements Runnable{
        private Clerk clerk;
        public Customer(Clerk clerk) {
			// TODO Auto-generated constructor stub
        	this.clerk=clerk;
		}
		@Override
		public void run() {
			// TODO Auto-generated method stub
			while(true) {
				try {
					Thread.sleep(1000);
					clerk.getProduct();
					System.out.println("消费者消费了第"+clerk.allGetProductNums+"个产品");
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
		}
		}
	}
	
}

Timer 计时器：

package am;

import java.util.Timer;
import java.util.TimerTask;

public class TimerTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
      Timer t = new Timer();
      t.schedule(new TimerTask() {
		
		@Override
		public void run() {
			// TODO Auto-generated method stub
			System.out.println("23124124");
		}
	}, 5,1000);
      Timer t1 = new Timer();
      t1.schedule(new TimerTask() {
		
		@Override
		public void run() {
			// TODO Auto-generated method stub
			t.cancel();
		}
	}, 5000);
	}

}

还有一个jar包 io.emmet,快速编写html等文件的，

然后下午就是反射了：

package pm;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;

//同步独木桥，异步大道
public class ReflectTest {
    public int count;
//    ReflectTest reflectTest = new ReflectTest();//正向，实例化过程 ，  反射，逆向反实例化过程
    //除方法体中的语句不能反射得到，其余的都可以得到。
    public ReflectTest() {
    	
    }
    public ReflectTest(int i) {
    	count=i;
    }
    public static void main(String[] args) throws Exception {
//		m2();
    	m3();
	}
    public static void m1(String[] args) throws ClassNotFoundException {
    	ReflectTest reflect = new ReflectTest();
    	Class<? extends ReflectTest> re1=reflect.getClass();//?就是一个类
    	Class<ReflectTest> re2 = ReflectTest.class;
    	Class<Integer> class1 = int.class;
    	Class<?> re3 = Class.forName("pm.ReflectTest");//类名就是全类名
    	URL url = reflect.getClass().getResource("");
			URL[] urls = new URL[] {url};
			URLClassLoader load = new URLClassLoader(urls);
			Class re4 =load.loadClass("pm.ReflectTest"); 	
    }
    
    public static void m2() throws Exception {
    	Class<?> re2 = Class.forName("pm.ReflectTest");
//    	ReflectTest re22 =re2.newInstance();
    	Object re22 =re2.newInstance();//实例化
    	Constructor<?> con = re2.getConstructor(int.class);
    	Object re23 = con.newInstance(2);
    	Constructor<?>[] cons = re2.getConstructors();//获得所有的public构造器
    	re2.getDeclaredConstructors();//获得所有的已声明的构造器
    	System.out.println(re23 instanceof ReflectTest);
    }
    
    public static void m3() throws Exception {
    	Class<?> re2 = Class.forName("pm.ReflectTest");
    	Field[] f1 = re2.getDeclaredFields();//得到属性
    	Field[] f2 = re2.getFields();
    	Field f3 = re2.getDeclaredField("count");
    	Object re3 = re2.newInstance();
    	f3.set(re3, 100);
    	Object value = f3.get(re3);
    	System.out.println(value);
    }
    
}

还有什么别的其它的就不和道了，无所谓了，先这样吧，没别的好说的了，结束。

aizaiee

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
THE TWENTY-FIRST DAY

今天星期三，参加培训的第二十一天，依旧是早起，然后吃饭到教室开始看书，今天问了一下舍友，applet果然是没怎么有人用了，还好吧，反正就是很让我纠结就对了。没什么别的好说的，objectinputstream 读空文件会产生EOF什么的异常，然后通过捕捉异常来进行操作就好了，其它的也没有什么讲的了，直接上代码了：先来今天查的知识：1、final,finally,finali...
复制链接

扫一扫

专栏目录