java视频总结

破壳成龙

一.Java简介
能力的三个层次：
知识：
    学习前人的知识
解决问题的方法：
    灵活运用学到的知识
解决问题的思路：
    创造解决问题的方法
Java两种核心机制：
Java虚拟机(可以理解成以字节码为机器指令的CPU)
垃圾收集机制
源程序(*.java)
通过java编译器变成
字节码(*.class)
通过类装载器，字节码校验器，解释器到操作系统平台运行
*.class在虚拟机上执行
java是解释行语言。
编译型语言是直接就可以编译成操作系统平台能够认识的文件
解释型语言是先编译成字节码，然后在由虚拟机解释成操作系统可以识别的文件
垃圾收集在Java程序运行中自动进行，程序员无法精确控制和干预
源文件中只能有一个public类，其他类的个数不限，如果有public类，那么源文件的名称必须以public类命名

二.基本数据类型
从本质上讲，变量其实是内存中的一小块区域，使用变量名来访问这块区域！那么这块区域多大呢？？？？不同的数据类型区域不一样大！比如整数类型有：byte short int long
那么怎么区分呢？byte在内存中占1字节 short占用2字节 int占用4字节 long占用8字节
Java语言的执行常量默认为int型，JVM看到整数就会把他当做int型，要想声明long型常量可以加L
浮点类型常量有两种表示方式：
十进制数形式：3.14 314.0
科学计数法：3.14e2 3.14E2
Java浮点类型常量默认为double型，如要声明float型，则需在数字后面加f或者F
float占4字节
double占8字节

重要：
基本数据类型转换：
整型，字符型，浮点型的数据在混合运算中互相转换，规则：
1.容量小(表示数的多少而不是内存的大小)的类型自动转换为容量大的类型；
byte,short,char->int->long->float->double
byte,short,char之间不会互相转换，他们三者在计算时首先会转换为int类型
2.容量大的数据类型转换为容量小的数据类型时候，要加上强制转换符，但可能造成精度降低或者溢出
long a=123 虽然整数类型默认是int  但是将int转换为long是由小的转换为大的，不会出错，但是a的值不能超过int的范围。
那么
float b=12.1 浮点型的默认为double，那么将double转换为float，是有大的转换为小的就会出现错误！
一般double不要强制转换为float
但是整型常量可以直接复制给byte,short，char等类型常量，不需要进行强制类型转换
但是不能超出其表示范围
3.有多种数据类型在进行运算的时候，系统首先自动的将所有的数据转换成容量最大的那一种数据类型，然后在计算
4.实数常量(如：1.2)默认为double
5.整数常量(如：123),默认为int

执行过程中的内存管理：
heap：new出来的东西
stack：局部变量
data segment:静态变量，字符串常量
code segment:存放代码

数组属于引用数据类型
常用数学工具包：java.lang.Math类帮助执行基本的数学函数的运算
三.运算符
自增运算符和自减运算符
在前时先运算在取值
int i1=10,i2=20
int i=(++i2);
先把i2的加，然后在把i2给i
在后时先取值在运算
int i1=10,i2=20
int i=(i2++);
先把i2的值赋给i，然后i2在加
“+”运算符两侧的操作数只要有一个是字符串(String)类型,系统会自动将另一个操作数转换为字符串后在进行连接。
当进行打印的时候，无论任何类型，都自动转化为字符串
switch(只能是int或者能转化为int的类型){
   case ....
}
方法:方法名(形式参数列表)
形式参数:在方法被调用时用于接受外界输入的数据
实参:调用方法时实际传给方法的数据
Java中进行函数调用中传递参数时，遵循值传递的原则：
基本数据类型传递的是该数据值本身，引用数据类型传递的是对对象的引用，而不是对象的本身。
重要：
和其它程序设计语言类似，Java语言的参数传递也分为两种：
1、 按值传递(by value)
适用范围：8种基本数据类型、String对象
特点：在内存中复制一份数据，把复制后的数据传递到方法内部
作用：在方法内部改变参数的值，外部数据不会跟着发生改变
2、 按址传递(by address)
适用范围：数组、除String以外的其他所有类型的对象
特点：将对象的地址传递到方法内部
作用：在方法内部修改对象的内容，外部数据也会跟着发生改变
以上特性是Java语言中的规定，在语法上无法指定参数传递是按值传递还是按址传递，但是可以通过下面的变换实现：
1、 对于按值传递的参数，如果需要在方法调用以后修改参数的值，可以利用返回值来实现。
2、 对于按值传递的参数，如果需要在方法内部修改时原来的参数不改变，则可以在方法内部重新创建该对象实现。
成员变量和局部变量的区别：
成员变量可以不赋值，会自动有默认值
局部变量必须初始化。
Student s=new Student()
在内存中会分配两块内存，首先s是变量(局部)放在栈内存中
内存的名字是s里面存放的值是堆内存的引用
new出来的值放在堆内存中
方法执行完毕，该方法内的变量申请的内存接着就消失！
“==”是比较两个变量的值是否相等，“equals”是比较两个对象变量所代表的对象的内容是否相等
明白了内存分配问题！

四.类
重载：方法名一样，里面的参数不一样
this可以看做是一个变量，它的值是当前对象的引用
static为类的公用变量，在第一次使用时被初始化，对于该类的所有对象来说，static 成员变量只有一份
注意：静态变量，字符串常量("abc")在data segment内存中
权限控制：
java权限修饰符public default protected private置于类的成员定义前，用来限定其他对象对该类对象成员的使用：
public类内部，同一个包下的类，子类，其他都可以方法
private只有类内部可以访问
protected类内部，同一包下的类，子类可以访问
default类内部，同一包下的类可以访问
对于class的权限修饰符只能用public default
public可以在任何地方访问
default类只可以被在同一个包下的类访问
方法的重写：
重写方法不能使用被重写方法更严格的访问权限
super是父类的引用
继承中的构造方法：
1.子类的构造的过程中必须调用其基类的构造方法
2.子类可以在自己的构造方法中使用super(...)调用基类的构造方法，使用this(..)调用本类的另外的构造方法,如果调用了super必须写在子类构造方法的第一行
3.如果子类的构造方法中没有显示的调用基类构造方法，系统默认调用基类无参数的构造方法
4.如果子类构造方法中没有显示的调用基类构造方法，而父类中又没有无参的构造方法，就会出错！

对象转型：
Anmimal a=new Dog(...);
那么a只能访问anmimal中的方法
要强制转型Dog b=(Dog)a;
动态绑定：
实际当中new的是什么类型，就调用谁的方法。
动态绑定是在执行期间判断所引用对象的实际的类型调用其相应的方法
动态绑定的三个条件：
1.要有继承
2.要有重写
3.父类引用指向子类对象
多态性表现：方法的重载和重写
final的变量的值不能被改变
final的成员变量
final的局部变量(形参)
fianl的方法不能被重写
final的类不能被继承
接口是抽象方法和常量的定义的集合
接口中声明的属性默认的是pulic static final,也只能是publci static final的
eg:public static final int id=1
自定义异常：
1.通过继承java.lang.Exception类声明自己的异常
2.在方法适当的位置生产自定义异常的实例，并用throw语句抛出
3.在方法的声明部分用throws语句声明该方法可能抛出的异常
class MyException extends Exception{
private int id;
public MyException(String message,int id){
super(message);
this.id=id;
}
pbulci int getId(){
return id;
}
}
注意：
重写方法需要抛出与原来方法所抛出异常类型一致异常或者不抛出异常
数组：
java中声明数组时候不能指定其长度，例如：int a[5];
二维数组：可以看成以数组为元素的数组
String是不可变的字符序列
StringBuffer是可变的字符序列
File类
java.io.File类代表系统文件名(路径和文件名)
public class Main {
/**
  * @param args
  */
public static void main(String[] args) {
  // TODO Auto-generated method stub
  File file=new File("D:/JavaEE-MyEclipse/Test");
  tree(file);
  
}
/**
  * 路径下面如果都是文件，返回true，否则返回false
  * @param file 传递过来的路径
  * @return
  */
public static boolean isAllFile(File file){
  if(file.isFile()){
   System.out.println(file.getAbsolutePath());
   return true;
  }
  File[] f=file.listFiles();
  int count=0;
  for(int i=0;i
}
枚举类型：
只能够取特定值中的一个
使用enum关键字

容器：
1.顶层接口Collection
2.Set和List两个接口继承Collection
3.HashSet类实现Set接口
4.LinkedList和ArrayList类实现List接口
5.接口Map，HashMap类实现Map接口
6.Set中的数据对象没有顺序且不可以重复(重复就是两个对象equals)
7.List中的数据对象有顺序且可以重复
Collection c=new ArrayList();这样做的好处是c只能访问collection的方法，不能访问ArrayList特有的方法，这样做的好处是可以换ArrayList。
8.容器类在调用remove和contains等方法时候需要比较对象是否相等，这会涉及到equals和hashcode方法；对于自定义的类型，需要重写equals和hashcode方法，什么时候用到hashcode？当自定义的对象是map中的key
9.Iterator接口的remove方法：删除游标左面的元素，在执行完next之后该操作只能执行一次
10.开始的时候游标在第一个元素的左面
11.除了简单遍历并读出其中的内容外，不建议使用增强for
12.List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素
13:List常用算法
  类java.util.Collections提供了一些静态方法实现了基于List容器的一些算法:.......
14.所有可以进行排序的类都实现了java.lang.Comparable接口
，该接口中中有一个方法
public int compareTo(Object obj)；该方法：
返回0表示this=obj
返回正数表示this>obj
返回负数表示this
16.Map的键值不能重复(equals)但是比较eqauls慢所以就用这个对象的hashcode来比较。
如果equals相等那么hashcode一定相等

Date类型
mysql中日期类型定义为datetime类型的！如果插入的是现在的时间，可以这样：
String sql="insert into table_name vaules(1,now())";将now（）函数（mysql系统函数）作为一个字符串插入到数据库中！
，如果不是现在时间，就先把字符串转化为日期类型，然后在插入。String date="2008-06-08";
Date d=new SimpleDateFormat("yyyy-MM-dd").parse(date);
读取格式化显示：
SimpleDateFormat fmt=new SimpleDateFormat("yyyy年MM月dd日hh小时mm分ss秒");
String aa=fmt.format(rs.getDate());
流：
.按照数据流的方向不同可以分为输入流和输出流
.按照处理数据单位不同分为字节流和字符流
.按照功能不同分为节点流和处理流
抽象流类型：
         
        
输入流：
InputStream字节流
Reader字符流
输出流：
OutputStream字节流
Writer字符流
我们说的输入和输出都是站在程序的角度上。
上面的类都是抽象类
多线程：
synchronized锁住的是当前对象
但是另外的线程可以访问没有锁定的方法

正则表达式:
用途:IP地址是否正确
     从网页中就出emial地址
     从网页中就出连接等
.:代表一个字符
*:代表






正则表达式：












public class Main11 {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
// p("abs".matches("..."));
// //\d代表以为数字
// p("a8729a".replaceAll("\\d","-"));
    //把正则表达式编译一下，放在p这个模式下面
// Pattern p=Pattern.compile("[a-z]{3}");
// Matcher m=p.matcher("fgh");
// p(m.matches());
   
// Pattern p=Pattern.compile("\\d{2}");
// Matcher m=p.matcher("23");
// p(m.matches());
//
//初步认识. * +
        /*p("a".matches("."));
        p("aa".matches("aa"));
        p("a".matches("aa*"));
        p("a".matches("aa+"));
        p("192.168.0.aaa".matches("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}"));
        p("192".matches("[0-2][0-9][0-9]"));*/
        /*//取并集
        p("A".matches("[a-z[A-Z]]"));//等同于p("A".matches("[a-zA-Z]"));
        p("A".matches("[a-z][A-Z]"));
        //取交集
        p("A".matches("[A-Z&&[RFG]]"));*/
        
        /*p(" \n\r\t".matches("\\s{4}"));
        p(" ".matches("\\S"));
        p("a_8".matches("\\w{3}"));
        p("abc888&^%".matches("[a-z]{1,3}\\d+[&^#%]+"));
        p("\\".matches("\\\\"));*/
        
        //边界匹配
        /*p("hello sir".matches("^h.*"));//开头的第一个字母是h
        p("hello sir".matches(".*ir$"));//以ir结尾
        // \b表示单词边界比如空格 换行等
        p("hello sir".matches("^h[a-z]{1,3}o\\b.*"));
        p("hellosir".matches("^h[a-z]{1,3}o\\b.*"));*/
        
        //空白行
        //p(" \n".matches("^[\\s&&[^\\n]]*\\n$"));
        
        //email
        //p("fkdajf@126.com".matches("[\\w[.-]]+@[\\w[.-]]+\\.[\\w]+"));
        
        //替换
        /*Pattern p=Pattern.compile("java",Pattern.CASE_INSENSITIVE);
        Matcher m=p.matcher("java Java IloveJava");
        p(m.replaceAll("JAVA"));*/
        
        //group 用（）括起来
        /*Pattern p=Pattern.compile("(\\d{3,5})([a-z]{2})");
        Matcher m=p.matcher("123aa-34345bb-234cc-00");
        while (m.find()){
            p(m.group(1));//
        }*/
        
        //抓取网页中的email
        /*File fileemail=new File("d:/email.txt");
        FileReader i;
        try {
            i = new FileReader(fileemail);        
        
        BufferedReader b=new BufferedReader(i);
        String line="";
        //读取一行的时候，其实并不能把所有的email地址都找出来，因为有可能@前面的字符和后面的字符不在同一行上面
        while((line=b.readLine())!=null){
            parse(line);
        }
        
    } catch (Exception e) {
        
    }*/
        
        
        
        
    }
    public static void parse(String str){
        Pattern p=Pattern.compile("[\\w[.-]]+@[\\w[.-]]+\\.[\\w]+");
        Matcher m=p.matcher(str);
        while(m.find()){
            System.out.println(m.group());
        }
    }
public static void p(Object o){
    System.out.println(o);
}
}


本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u2/76927/showart_1968244.html