数据库连接失败：
jdbc:oracle:thin:@localhost:1521:orcl
提示错误：
ora-12505：TNS：监听程序当前无法识别连接描述符中所给出的SID等错误。
解决方法：
找到oracle安装目录中的tnsnames.ora文件，查看文件内容是否和连接字符串一致。
（正确连接字符串：jdbc:oracle:thin:@localhost:1521:XE）XE = (DESCRIPTION = (ADDRESS = (PROTOCOL = TCP)(HOST = PC201604080955)(PORT = 1521)) (CONNECT_DATA = (SERVER = DEDICATED) (SERVICE_NAME = XE) ) ) EXTPROC_CONNECTION_DATA = (DESCRIPTION = (ADDRESS_LIST = (ADDRESS = (PROTOCOL = IPC)(KEY = EXTPROC_FOR_XE)) ) (CONNECT_DATA = (SID = PLSExtProc) (PRESENTATION = RO) ) ) ORACLR_CONNECTION_DATA = (DESCRIPTION = (ADDRESS_LIST = (ADDRESS = (PROTOCOL = IPC)(KEY = EXTPROC_FOR_XE)) ) (CONNECT_DATA = (SID = CLRExtProc) (PRESENTATION = RO) ) )最初的myeclipse是eclipse的一个插件，后来直接整合成一个完整的Java开发工具
代码右键功能：
refactor–>Extract (method/interface/superclass)
重构一个抽象的方法/接口/父类
surround with–>try..cath/do..while/for../if..
使当前选择代码放入指定模板中（类似于sysout Alt+/）
自定义模块：window–>preferences–>java–>editor–>templates
也可以选中代码然后使用Alt+/调用快捷模板
jdk1.5开始可以使用静态导入功能，直接使用方法名不需要再写类名
import static java.lang.Math.max; 或者（import static java.lang.Math.*;）
Math.max()–>max()运行Java代码提示错误
Bad Version number in .class file
高版本的java能运行低版本的javac编译的程序，低版本的java不能运行高版本的javac编译的程序javac:编译环境
java:运行环境（jre）查看版本信息：
window–>preferences–>java–>compiler(javac版本)、installed Jres（java版本）
工程右键–>properties–>javacompiler(javac版本)、run/debug settings(java版本)
java页面右键–>run as–>run configurations–>java application–>jre(java版本)修改jdk
工程右键–>build path
jdk和jre的解释
jre:java runtime environment
jdk:java development kit
jre是java运行环境，包含了java虚拟机java基础类库，是提供给运行java程序的用户使用的
jdk中包含了jre和编译java源码的编译器javac，提供给使用java语言开发程序的人员使用的java类中的toString()方法
用System.out.println()输出一个对象的时候，java默认调用对象的toString()方法
如果一个类User，有id，name属性，直接输出user对象的话得到的是全限定名@地址首地址
如果在类user中覆盖toString()方法就能输出你想要的
eg:public String toString(){
return: “user name is :”+this.name+”; user id is :”+this.id;
}构造方法私有化
构造方法私有化将不能在外部实例化这个类的对象，只能在类内部实例化这个类的对象在外部调用，它的类内部方法使用static修饰无意义——-外部没有实例化能力，单例设计模式，实现从头至尾只有一个对象的实例
--普通类模拟枚举类的实现原理
public class WeekDay {
//构造方法私有化
private WeekDay() { };
public final static WeekDay MON = new WeekDay();
//成员变量实例化
public final static WeekDay SUN = new WeekDay();
//普通类方法，每个成员都可以调用
public WeekDay nextDay() {
if (this == MON) {
return SUN;
}
else {
return MON;
}
}
} --将普通类变为抽象类
public abstract class WeekDay {
private WeekDay() { //构造方法私有化
};
//1、用匿名内部类的方式构造子类；2、子类对象实例化
public final static WeekDay MON = new WeekDay(){
@Override
//实现抽象方法
public WeekDay nextDay() {
return null;
}};
//public final static WeekDay SUN = new WeekDay();
//抽象类方法，每个子类必须实现该方法才可以使用
//（此处可以将大量的if.else语句转移成了一个个的类）
public abstract WeekDay nextDay();
}final
类：不能被继承（没有子类，类中的方法默认为final）
方法：可以在子类中被继承，但不能被子类方法覆盖
常量：只能赋值一次，值不再改变（可以先声明，不赋值，但是要确保空白final使用之前必须赋上值）
如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。static
修饰成员变量和方法，可以直接通过类名调用（当然也可以通过对象调用）
静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字
static静态方法是不能被子类重写(也叫覆盖)，因为子类如果有同名的静态方法那是属于子类自己的。
明确一个概念，静态方法是属于类的方法，普通方法是对象的方法。
static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract（抽象方法在子类中才被实现）。
11、abstract
含有abstract修饰符的类即为抽象类，抽象类不能创建实例对象。
含有abstract方法的类必须定义为抽象类，抽象类中可以包含普通方法。
抽象类中定义抽象方法必须在子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类。jdk1.5之后的新特性（枚举、注解）
一、variable parameter 可变参数
用“…”代表，位于参数类型和名称之间，并且只能出现在参数列表最后
eg:
public int add(int x,int ... args){
int sum=0;
for(int arg:args){ //for循环增强
sum+=arg;
}
return sum;
} 调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数
二、自动装箱、自动拆箱
Integer i=3; ---(自动装箱：自动将基本数据类型装成一个对应的对象赋给引用变量)
System.out.println(i+12); ---(自动拆箱：自动将对象转成基本数据类型进行加法运算)
享元模式：对于小的整数，装箱成的对象是同一个
eg:
Integer num1=12;
Integer num2=12;
System.out.println(num1==num2); //true
Integer num3=128;
Integer num4=128;
System.out.println(num3==num4); //false枚举enum
枚举是一种特殊的类，枚举的每个元素都是该类的一个实例对象
其中也可以定义构造方法(私有)、成员变量、普通方法和抽象方法。简单枚举
public enum WeekDay{
sun,mon(2),tue,wed,thi,fri,sat;
//枚举的构造方法必须是私有的，默认调用这个不带参数的
//那么这个枚举的构造方法该如何调用呢
//私有构造方法是无法在类的外部调用的
//只能在成员变量后面添加参数了
//例如sun(1),mon(2),tue，不同的成员对应不同的构造方法
private WeekDay(){};
private WeekDay(int day){};
}
//枚举对象只能这样定义（从类中取出一个对象）
//而且枚举类中每个对象都会调用一次对应的构造方法
WeekDay wek=WeekDay.fri; 复杂枚举
public enum TrafficLamp{
RED(30) {
@Override
public TrafficLamp nextLamp() {
return GREEN;
}
},GREEN(45) {
@Override
public TrafficLamp nextLamp() {
return YELLOW;
}
},YELLOW(5) {
@Override
public TrafficLamp nextLamp() {
return RED;
}
};
public abstract TrafficLamp nextLamp();
public int time;
private TrafficLamp(int time){this.time=time;};
}Class—->反射的基石。
我把Classs理解成java中所有类型的一个泛型，它可以获取到类型的成员变量，成员方法，构造方法，修饰符，包信息等等等等。
类名是Class，此Class非彼class
public class persion;—->persion是一个类class(讲的不是这个class)persion p1=new persion();
Class c1=p1.getClass();—->获取persion的字节码(讲的是这个Class)对象.class类型是Class
//用反射的方式实现这样的效果：
new String(new StringBuffer("abc"));
//1、获取构造方法(根据参数类型获取不同的构造方法)
Constructor constructor1 = String.class.getConstructor(StringBuffer.class);
//2、构造方法实例化（要和构造方法参数类型保持一致，否则运行会出错）
String str = (String)constructor1.newInstance(new StringBuffer("abc"));
/**
为什么要使用(String)转换类型--区分编译时和运行时
编译时只知道constructor1是一个构造方法，运行时才知道它是String.class的构造方法
class自身也有一个newInstance()方法
class.newInstance():直接实例化一个不带参数的对象;
等同于
class.getConstructor().newInstance();**/成员变量的反射
Field是类上的成员变量，和对象无关，获取Field的值需要绑定对象【Field对象.get(对象名称)】;
声明一个类的对象p1,其中x是对象中的私有字段
//出错，x是私有方法，会提示没有该成员字段
Field fx1=p1.getClass().getField("x");
//Declared获取所有声明过的字段
Field fx=p1.getClass().getDeclaredField("x");
//私有类型使用会出错，会提示该字段私有不可使用
System.err.println(fx.get(p1));
//暴力反射，私有类型也要取出来使用
fx.setAccessible(true);
System.out.println(fx.get(p1));
成员方法的反射
Method m=String.class.getMethod("charAt",int.class);
m.invoke(对象,2);如果是静态方法对象可以为null
快捷键
在代码上面摁F2出现完整类路径
Integer和int和Object
int是基本数据类型
Integer是int的包装类，目的是类型间的相互转换
而Object是所有类的父类，
所以：基本数据类型不是ObjecthashCode
Java中的集合（Collection）有两类，一类是List,再有一类是Set
List中元素是有序，可重复的。Set中元素是无序，不可重复的。
——如何判断不可重复？
hashCode根据值将集合分成不同区域，在查找时在对应区域内找（插入时也是，所以插入效率低）。
对象定以后就不要更改对象中对hashCode有影响的属性值，因为hashCode值改变，删除的时候会在新的区域内查找要删除的对象（当然找不到了，而且旧的对象仍然存在，会造成内存溢出）——为什么要覆盖hashCode和equals方法才能正常使用hashcode，不覆盖生效么？
equals()和hashcode()都是从object类中继承过来的，
equas()在object类中实现方法是判断对象的引用地址是否一致（String、Math、Integer、Double…等封装类已经覆盖了object中的equals()方法，比较的是内容）
hashcode()在object类中定义是public native int hashCode();为本地方法。内部类
内部类可为静态，可用protected和private修饰（外部类只能使用public和缺省的包访问权限）
内部类主要有：成员内部类、局部内部类、静态内部类、匿名内部类
内部类的作用：每个内部类都能独立地继承自一个（接口的）实现，使用内部类可以有效的实现“多重继承”。
内部类是一个编译时的概念，一旦编译成功就会成为完全不同的两类。对于Outer和它的内部类inner，编译后会出现
outer.class、outer$inner.class两个类文件成员内部类（非静态内部类）
非静态内部类中不能定义静态成员 非静态内部类中可以访问外部类的所有成员 内部类和外部类的实例变量可以共存（同名） 内部类中访问内部类自己的成员变量：变量名 或 this.变量名 内部类中访问外部类中同名成员变量：OuterClass.this.变量名 如果内部类和外部类变量名不同可以直接使用变量名访问 外部类非静态方法访问成员内部类: InnerClass inner=new InnerClass(); inner.Method1(); 外部类静态方法访问成员内部类： OuterClass outer=new OuterClass(); InnerClass inner=outer.new InnerClass(); inner.Method1();局部内部类
在方法中定义的内部类称为局部内部类。 局部内部类可以访问方法内的变量，但变量必须是final的 访问局部内部类必须先后外部类对象 OuterClass outer=new OuterClass(); Outer.Method1();----Method1()中包含了局部内部类静态内部类（嵌套类）
静态内部类可以使用public、protected、private修饰 静态内部类可以定义静态或者非静态成员 静态内部类只能访问外部类的静态成员（包括静态变量和静态方法） 外部类访问内部类的静态成员：内部类.静态成员 外部类访问内部类非静态成员：实例化内部类即可 InnerClass inner=new InnerClass(); inner.Method();/inner.var1;匿名内部类
匿名内部类就是没有名字的内部类 ---什么时候使用匿名内部类？ 只用到类的一个实例 类在定义后马上用到 类非常小 给类命名并不会导致你的代码更容易被理解 ---匿名内部类的使用原则 匿名内部类不能有构造方法 匿名内部类不能定义任何静态成员、方法、和类 匿名内部类不能是public、protected、private、static 只能创建匿名内部类的一个实例 一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类（子类） 匿名内部类其实为局部内部类的一种，所有已局部内部类的所有限制都对其生效break、continue、return
break：结束所在循环，结束外层循环(外层循环语句前面添加标识 outer: ,需要在内层循环中结束的时候 break outer;)
continue:结束本次循环，继续循环；
return:结束一个方法，当然所有循环都终止。
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
