eclipse中文日蚀
至今活下来的是eclipse和idea
怀念Borland
已经流行大量的数据库
考虑到环境
JDBC针对关系型数据库的开发服务
现在的数据库分关系型和nosql数据库,由项目业务决定
程序 jdbc 接口 对应操作 接口由数据库生产商提供
针对不同的书苦苦由不同的数据驱动,
jdbc_odbc连接 利用微软的odbc进行连接,性能在最差
jdbc连接 直接利用各个生产商提供的 数据驱动 性能在最好
网络连接 集群 网络协议连接
现在用的是第二种
jdbc所有的开发操作对在java
1个类三个接口
sql中
一个类 drivermannerger
接口 connection statement [re[arestatement接口
'
例如现在要求我们设计一个求任意个数（整数）的和，我们可以这样来写
----------------------------------------
package day1;
public class Test {
public static void main(String[] args) {
System.out.println(add(new int[] {1,2,3,4}));
}
public static int add(int[] date){
int x = 0;
for(int i=0;i<date.length;i++){
x +=date[i];
}
return x;
}
}
--------------------------------------------
这种是最初实现，有一定缺陷，例如说，我现在想写一个任意参数的求和,而不是数字
System.out.println(add(1,2,3));这时上面的代码将报错,这时可以使用可变参数
语法:Public [static] [final] 返回值 方法名称(参数类型 … 参数名称){}//[]代表可选
例如：
---------------------------------------------------------
package day1;
public class Test {
public static void main(String[] args) {
System.out.println(add(1,4));//随意传递的值
System.out.println(add(new int[] {1,2,3,4}));
}
public static int add(int ... date){//本身还是一个数组
int x = 0;
for(int i=0;i<date.length;i++){
x +=date[i];
}
return x;
}
}
------------------------------------------------------------------
使用原则:参数个数不却定，随意由用户传递
注意：如果要传递多类参数，可变参数要写到最后例如
public static int add(String arg,int ... date){}
----- 请解释final, finally, finalize的区别
·final: 是一个关键字, 修饰类和方法时等于C#的sealed, 修饰变量时等于C++的const
·finally: 是异常处理的统一出口 (try catch finally)
·finalize: Object类中的方法, 等于C++的析构函数
向下转型是不安全的操作，会带来隐患。
System.currentTimeMillis();
final、finally、finalize 的区别：
final是一个关键字，用于定义不能够被继承的父类、不能够被覆写的方法和常量
finally是异常处理的统一出口
finalize是Object类中的一个方法，用于在回收调用前进行处理。
泛型接口其子类有两种实现方式
第一种：实现类同样为泛型
interface Mytest<T>{
public void print(T t);
}
//第一种
public class testImpl01<T> implements Mytest<T>{
public void print(T t){
}
}
第二种：
public class testImpl02 implements Mytest<String>{
public void print(String t){
}
}
解决数据的重复设置或重复取出，需要等待及唤醒机制
public final void wait ()throws InterruptException;死等
public final void wait(long timeout) throws InterruptedException; 活等
public final void notify();
唤醒第一个
public final void notifyAll(）；
唤醒所有
package com.pra.synchronizedcase.union;
class Data{
private String title;
private String note;
//flag=true 表示允许生产，但是不允许消费者取走
//flag=flase 表示不允许生产，但允许消费者取走
private boolean flag = true;
public synchronized void get() {
if(flag==true){
//已经生产了，不允许重复生产
try {
super.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
try {
Thread.sleep(50);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(this.title+"="+this.note);
flag=false;
super.notify();
}
public void set(String title,String note) {
this.title = title;
if(flag==false){
try {
super.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
flag=true;
super.notify();
this.note = note;
}
}
请解释sleep()与wait()的区别
sleep()是Thread类中定义的方法，到了一定的时间可以自动唤醒
wait()是Object类中定义的方法，如果要想唤醒，必须使用notify()或者notifyAll()方法
@FunctionalInterface 函数式编程的注解只能有一个抽象方法
函数编程() ->单行语句
()->{
多行语句
}
@Deprecated 过期声明
1.任何的实例化对象可以通过Objec类中的getClass（）方法取得Class类对象：
2.“类.class”:直接根据某一个具体的类来取得Class类的实例化对象：
3.使用Class类提供的方法： public static Class<?> forName(String className) throws ClassNotFoundException
在以上的三个方法里面我们会发现一个地方，除了第一种形式会产生Date类的实例化对象以外，其他的两种都不会产生Date类的实例化对象。于是取得了Class类对象有一个最直接的好处：可以直接通过反射实例化对象。在Class类里面定义有一个方法：
newInstance():
除了关键字new之外，对象的实例化有了第二种方式，通过反射进行。
取得了Class类对象，就意味着取得了一个指定类的操作权。
反射机制：反射指的是对象的反向处理操作，首先需要来观察一下“正”的操作。在默认情况下，我们必须要先导入一个包，而后才能产生类的实例化对象。
所谓的“反"指的是根据对象类取得对象的来源信息，而这个“反”的操作核心处理就在于Object类的一个方法：
取得Class对象：public final Class<?> getClass():该方法返回的是一个Class类的对象，这个Class描述的就是类。
在反射的世界里面他所看重的不再是一个对象，而是对象身后的组成。（类，构造，普通，成员等）
泛型只能用引用类型，不能用基础数据类型
序列化与反序列化操作，需要用到IO中两个类：
ObjectOutputStream:
ObjectInputStream:
对象序列化操作：
基本实现：指的是将在内存中保存的对象变为二进制数据流的形式进行传输，或者将其保存在文本中。并不意味着所有的类都能被实例化。需要传输使用，并实现Serializable接口。
序列化对象时所需要保存的就是对象中的属性，所有默认情况下对象的属性将转为二进制数据流存在。
文件流的操作里面一定会产生一个文件数据（不管最后这个文件数据时候被保留），那么现在的要求是需要发生IO处理，那么有不希望产生文件，就可以使用内存作为操作的终端。
方法引用--给方法起别名
引用静态方法 类名:: static 方法名
-----利用已经存在大代码
引用对象方法 对象:: 方法名
引用特定类方法 类名称::方法名
引用构造方法 类名称:: new
在JDK1.8才能使用。
线程
如果现在要求你处理的数据都在inputstream里面需要输出。
package p.com.utik;
class Data{
private String title;
private String note;
public synchronized void set(String title,String note)
{
this.title=title;
this.note=note;
}
public synchronized String get()
{
return this.title+" "+this.note;
}
}
class DataProvider implements Runnable{
private Data data;
public DataProvider(Data data) {
this.data=data;
}
@Override
public void run() {
for(int i=0;i<50;i++)
{
if(i%2 == 0)
{
this.data.set("zhangsan","is bad man");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}else{
this.data.set("People","are hard-working");
}
}
}
}
class DataGettor implements Runnable{
private Data data;
public DataGettor(Data data) {
this.data=data;
}
@Override
public void run() {
for(int i=0;i<50;i++)
{
try {
Thread.sleep(50);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(this.data.get());
}
};
}
public class TestDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
Data data=new Data();
new Thread(new DataProvider(data)).start();
new Thread(new DataGettor(data)).start();
}
}
同步问题得到解决，但无法解决交替问题
