CoreJava基础笔记 v1.0

********************************COREJAVA**********************************

编译器默认添加的代码:

1.   import java.lang.*;

2.   若是一个类没有定义任何构造方法,编译器默认添加public 无参,空构造方法

3.   调用方法以前,若是没写引用,默认为"this."

4.   若是一个构造方法的第一行,不是this(...)或者super(...),默认添加"super();"

5.   若是一个类没有指定父类,默认继承Object类

6.   5.0以后,编译器自动完成简单类型和包装类之间的转换

7.   5.0以后,编译器自动将for-each代码翻译为迭代遍历

===============================java入门介绍================================

Java 95 Sun

编程语言 程序

人----指令----> 计算机

源程序:文本文档

  .exe  可执行

编译: 源文件(文本文件)  (编译器)---->   机器码文件(可执行文件)  

      执行效率高  不能跨平台   (C C++)

解释: 源文件(文本文件)  (解释器 逐行翻译并运行)---->

      执行效率低    (JavaScript Basic)

先编译 后解释

源文件(.java)  ----->(编译)  字节码文件(.class) ---->(解释器)

JVM:屏蔽不一样OS的差别,最终实现跨平台性.

JRE(Java 运行环境) = JVM + 解释器 

JDK(Java开发工具包)= JRE + 编译器 + 类库 + 工具

跨平台性

面向对象

简单性(和C++对比)

================================准备知识============================

javac 源文件的文件名 (包括.java)   一个类对应着生成一个.class文件

java  类名(不包括.class)            

1. 安装JDK

2. 设置三个环境变量

   Java_Home  =  JDK的安装目录

   Path       =  JDK的安装目录/bin

   ClassPath  =  .   (类路径 指示编译器或虚拟机到哪里找所须要的类文件)

3. 编写一个类 编译运行

公开类的类名,必须和源文件的文件名彻底相同

import 语句   用到某个类的时候,不写包名

=============================java================================

1.注释  描述性的文字    可读性 代码质量

    //       单行注释 

    /*  */   多行注释     /* 不能嵌套

    /** */   多行注释     被JavaDoc工具所读取,并单独生成JavaDoc文档

    缩进

    每行一句代码   一句代码一行

    根据程序层次关系,作好缩进  每进入一个代码块,须要缩进一次

    若是一句代码要换行,也要缩进

2.标识符 程序各个组件的名字

    语法:字母 数字 下划线 $ 组成  数字不能开头

         大小写敏感  没有长度限制

         不容许使用关键字

    习惯:望文知义

            包名           全小写            helloworld

            类名           单词首字母大写    HelloWorld

            方法/变量名    首单词小写,后面的单词首字母大写  helloWorld

            常量           全大写            HELLOWORLD

3.变量 表明了JVM内存中一个存储空间

    强类型 变量的类型和变量中存储的数据类型必须一致

    数据类型 2种

    简单类型(基本类型)

        byte    1B      -128 -- 127

        short   2B      -32768 -- 32767

        int     4B      -2147483648 -- 2147483647

        long    8B      -2^63 -- 2^63-1            字面值加L或l

        float   4B      字面值加F或f

        double  8B      字面值加D或不加    1.3E10  1.3*10^10

        boolean         布尔  字面值 true false

        char    2B      字符 采用Unicode编码 

                        字面值 'A' 65 '\u0041'

                        转义字符 \n \t \' \" \\

    对象类型

        String  字符串  字面值 ""

4.表达式 

    将常量,变量以及字面值,经过运算符链接而成 

    类型自动提高  a+b

        a,b 有double ==> double

        a,b 有float  ==> float

        a,b 有long   ==> long

                     ==> int

    运算符

        + - * / %

        = += -= *= /=     ++ --    a++ ++a   不发生类型提高

        == > < >= <=  !=  

        &&　|| !    

        (布尔表达式)?值1：值2   

        & | ^ ~

        >>  << >>>(无符号右移)

5.局部变量  定义在方法内部的变量

    1. 必须先赋值,再使用

    2. 做用范围:从定义开始,到它所在的代码块结束

    3. 重合范围内,不容许两个同名的局部变量

6.程序执行流程

    条件分支

        if(布尔表达式){}

        if(布尔表达式){}   else{}

        if(条件1){}

        else if (条件2){}

        else if (条件3){}

        a = (b>c)?2:1;

        if(b>c){

            a = 2;

        }

        else{

            a = 1; 

        }

        switch-case

        switch(int型表达式)  byte,short,int,char

    循环

        while(布尔表达式){}        0 - n 次    不肯定循环

        do{} while(布尔表达式);    1 - n 次    不肯定循环

        for( 定义循环变量 ; 循环条件  ; 循环变量的变化 ){}   0 - n 次  肯定循环次数

        break       跳出循环

        continue    跳出本次循环

==================================函数=================================

类--函数--语句

冗余代码  可维护性  

定义函数(声明函数):static 返回值类型 函数名 (参数表)  //形式参数 形参

          形参至关于函数内部有效的局部变量

实现函数  {}  return 函数返回  return 返回值;

调用函数  函数名(参数); //实际参数实参给形参赋值

函数做用

减小冗余代码,便于维护

可重用性

程序结构清晰 便于分工  非结构化(语句为单位)-->结构化(函数为单位)

==============================数组==================================

数组

一次性定义多个同类型的变量

为数组分配空间 长度为n

a[0] a[1] a[2] .... a[n-1]   下标 0 -- (n-1)

数组元素的默认值:  数值类型 0  布尔类型 false 对象类型 null

数组名.length : 数组的长度

int[] a ;

a = new int[]{1,2,3};

int[] a ={1,2,3};

==============================面向对象================================

面向过程:从程序执行流程出发

面向对象:从客观世界出发

    数据 JVM内存中的一块存储空间

    客观世界:任何客观存在的事物

           有什么:属性

           能作什么:方法

    1.对象的属性能够是另一个对象

    2.对象调用另外的对象的方法

    计算机中的对象表明了客观生活中的对象

生活中的解决需求的思路移植到计算机中

先把解决问题所须要的对象准备好,再让对象间发生联系,从而解决问题

①各司其职: 对象简单 由简单的对象组成复杂的系统

②弱耦合性: 对象之间的联系尽量的弱

③可重用性: 对象能够重复使用

④可扩展性: 在原有对象的基础上,扩展出新的对象

------------------------------------------------

类

对象的模板  该类对象具备哪些属性和方法

对象的抽象 人对对象的主观认识

属性:实例变量(成员变量)

1. 有默认值 (0 false null)

2. 做用范围至少是全类内部

3. 容许和局部变量同名,同名时局部变量优先

方法: 

声明/定义   修饰符 返回值类型 方法名 (参数表) 抛出的异常

            对象能作什么

实现   {}   对象怎么作

重载(Overloading) 方法名相同 参数表不一样 返回值,修饰符无要求

参数个数不一样

参数类型不一样      m(int a)   m(double d)

参数类型排列不一样  m(int a,double d)  m(double d , int a)

只是参数名不一样,不算重载  m(int a)  m(int b)  

对象的同类方法,因为参数表的不一样所形成的差别,对用户屏蔽

编译时多态:由编译器,根据实参类型,选择正确的方法来调用

构造方法

1.方法名必须和类名相同

2.没有返回值类型

3.不容许手工调用,只会在对象构造过程当中,自动调用一次

this 

1. 调用本类其余的构造方法  必须出如今构造方法的第一行

2. this. 当前对象  区分实例变量和局部变量

建立对象的过程

1.分配空间     属性被赋予 默认值

2.初始化属性   属性被赋予 初始值

3.调用构造方法 属性被赋予 构造参数

new 类名(参数1，参数2，参数3 ...);

简单变量: 存值

对象变量(引用):存地址

Java中的方法参数传递规则

  简单类型参数传值   对象类型参数传引用 (实参,形参共同指向同一对象)

=============================面向对象的三大特性===============================

三大特性

封装

    属性私有,提供set/get方法. 便于控制

继承

    类之间造成 通常-特殊 关系    父类(超类) --- 子类(派生类)

    子类的共性 放在父类

    

    单继承  每一个类只能有一个直接父类  类之间造成简单的树状结构

    private    本类内部       不能继承

    (default)  本类+同包      同包子类能够继承 

    protected  本类+同包+子类 能够继承 

    public     公开           能够继承 

    构造方法不能继承给子类

  

    方法覆盖(Override)

    子类用特殊的方法实现,替换掉父类继承给它的通常实现

    方法名,返回值类型,参数表 必须相同 访问修饰符相同或更宽 

    

    this

    1. 引用 当前对象  this.  区分实例变量和局部变量

    2. 构造方法 调用本类其余构造方法 必须放在第一行

    super

    1. 引用 父类对象  super. 访问父类被遮盖的属性,或调用父类被覆盖的方法

    2. 构造方法 调用父类构造方法 必须放在第一行

    对象构造过程:jmm

    1.分配空间 属性被赋予默认值 

    2.构造父类对象

    3.初始化本类属性 属性被赋予初始值

    4.调用本类构造方法   属性被赋予构造参数

    A --B --C

    分配空间

    初始化A属性

    调用A构造方法

    初始化B属性

    调用B构造方法

    初始化C属性

    调用C构造方法

多态  子类的对象能够赋值给父类的引用

    1. 对象类型不变

    2. 只能对引用,调用其引用类型中定义的方法

    3. 运行时,根据对象类型,运行子类覆盖以后的方法

    屏蔽不一样子类的差别,灵活.弱耦合性

   

    多态用在方法的参数上: m(A a):m方法接受A类或A的任何子类对象为参数

    多态用在方法的返回值上: A m():m方法可能返回A类对象,或A类某个子类对象

    

    子类引用赋值给父类引用,能够直接赋值

    父类引用赋值给子类引用,须要强转.运行时可能发生类型转换异常

    引用 instanceof  类名  布尔表达式  判断引用中的对象和类型是否兼容

    "引用中的对象 是否是 类名"   

    在类型转换以前,用 instanceof 判断类型兼容,从而避免类型转换异常

=============================修饰符========================================

修饰符 

private     属性 方法 构造方法

public      属性 方法 构造方法  类

protected   属性 方法 构造方法

(default)   属性 方法 构造方法  类

abstract 抽象的

类    只能声明引用 不能建立对象    

方法  只有定义,没有实现

若是一个类中有抽象方法,这个类必须是抽象类(抽象类未必有抽象方法)

子类继承抽象类,若是子类不但愿也成为抽象类,就必须实现父类中全部抽象方法

final

变量   一旦赋值,不能改变 (常量)

       final属性没有默认值,用户必须主动赋值(初始化属性,构造方法)

类     不能被继承

方法   不能被覆盖

 

static 静态

属性

    静态属性不属于任何对象,全类公有  能够用类名访问

方法

    静态方法能够直接用类名调用

    静态方法不能访问类的非静态成员(包括this)

    静态方法只能被子类的静态方法覆盖,并且没有多态

      对一个引用调用静态方法,等同于对引用类型调用静态方法

初始代码块  

    静态初始代码块  类加载的时候执行一次

    

    类加载:当JVM第一次使用一个类的时候,经过ClassPath找到这个类对应的.class文件,将这个文件中包含的类的信息读入JVM并保存起来

    "使用一个类":建立类的对象;调用类的静态方法;访问类的静态属性

    声明引用 不会发生类加载!!!!!

 

    类加载的过程:

    1. 若是须要的话,加载父类

    2. 按照定义的顺序,初始化静态属性或是运行静态初始代码块

修饰符组合

private   

static               abstract

final

===============================接口 interface=============================

接口   特殊的抽象类

    1.全部属性都是 公开 静态 常量

    2.全部方法都是 公开 抽象方法

    3.没有构造方法

一个类实现接口,若是这个类不但愿成为抽象类,就必须实现接口中全部方法

接口之间能够多继承

一个类在继承另一个类的同时,还能够实现多个接口

用接口实现多继承,没有破坏类之间树状关系的简单性

    子类引用赋值给父类引用,能够直接赋值

    父类引用赋值给子类引用,须要强转.运行时可能发生类型转换异常

    不相干的两个类的引用,不能强转(编译不经过)

    两个引用之中,若是有接口类型,则必定能够强转(编译经过)

解耦合工具

定义接口就是定义标准  把标准的实现者和标准的使用者分离

==================================内部类===================================

1.内部类 :<定义类内部的类----能够访问外部类的私有成员 ,独立的类,编译后生成单独的 .class 文件 >

1.成员内部类

使用 外部类类名.this 访问外部类的当前对象

建立成员内部类对象,必须先建立外部类对象,

外部类对象.new 内部类类名

成员内部类中,不容许定义静态成员!

Outer out = new Outer();

Outer.Inner in = out.new Inner();

2.静态内部类

能够定义静态成员

只能访问外部类的静态成员

经过外部类类名.内部类类名 直接建立对象

Outer.StaticInner in = new Outer.StaticInner();  

3.局部内部类

定义在外部类的方法中

做用范围:外部类的方法内部 

不只能够访问外部类的成员,还能够访问外部类声明为final的局部变量

4.匿名内部类

特殊的局部内部类

必须是继承某个类或者实现某个接口

只会建立该类的一个对象(只会new一次)  

不只能够访问外部类的成员,还能够访问外部类声明为final的局部变量

没法定义构造方法

        格式:

            Teacher t1 = new Teacher(){

                public void teacher(){}

            };

       匿名内部类访问外部类的局部变量的时候,只能访问,final修饰的，注意参数

=================================java-API=====================================

1.Object ---java全部类的父类 

    1.Object类的引用能够存任何对象;

    2.Object 类中的方法便是全部对象的方法,

    3.方法:

           1.getClass():返回对象的实际类型 

类型 引用 = new 类型();

           2.finalize():在对象被垃圾回收器回收时,最后自动调用的方法;

           3.toString():返回对象的字符串形式

public String toString(){}

           4.equals():比较两个对象的内容是否相等

  class 类{

                   public boolean equals(Object o){

                        //判断自反性

                        if(this == o)return true;

                        //判断非空

                        if(o == null) return false;

                        //判断对象运行时的类型是相同

                        if(this.getClass() != o.getClass()) return false;

                        //类型强转

                        Student s = (Student)o;

                        //比较对象的内容

                        ……………………………………

                        return true;

                        else return false;  

                   }

}

引用.equals(引用2);

2.包装类 :8中基本类型的对象类型;

    <int------Integer>              int-->String   int n = Integer.parseInt(str);

    <char-----Character>

    <long-----Long>---id  

    JDK5.0的特性   自动封箱;

================================String类=================================

1.String  ----不变的对象．．．．利用串池实现共享

使用串池累加字符串时,会产生大量的中间对象,影响性能,因此使用StringBuilder/StringBuffer(JDK1.0)

    1.charAt(int pos)//得到字符串中第pos下标的字符

    2.indexOf(String str),//得到str字符的下标

    3.split(String s)//以“s”为分割符拆分字符串

    4.subString(int start , int end);//得到子串,从start位置开始,到end结束,包括start下标,不包括end下标 

    5.toCharArray()//把字符串拆分红字符数组 char[]

    6.trim();//去掉字符串先后的空格换行等格式字符

        面试题:String str = new String("abc");//该代码产生两个对象,

//首先在串池中产生一个对象,而后再栈内存中new一个对象 

        StringBuilder/StringBuffer  //实现字符串拼接,能够提升性能

=====================================集合框架===============================

1.集合框架<容器----储存对象的对象>

    1. interface Collection{接口:元素都是Object}

---子接口<List/Set>

       方法:1. boolean add(Object o);//将对象o放入集合中,成功返回true,不然返回false；

            2. boolean contains(Object o)//判断o元素是否存在集合中

            3. boolean isEmpty()://判断集合是不是空的

            4. Iterator iterator()://建立迭代器,用于迭代遍历

            5. remove(Object o)://删除o元素;

            6. void clear();//清空

            7. int size();//获得集合的大小

        1.List<List元素有顺序,能够重复>-----(能够用下标遍历)

                1. void add(Object o)//添加o元素到集合中

                2. void add(int index,Object o)//把o添加到index下标位置

                3. Object get(int index)//获得index位置上的对象

                4. void set(int index,Object o)//将index位置上的元素改变o对象

                5. int indexof(Object o)//返回元素o的下标,若是不存在,则返回-1

6. remove(int pos)//删掉pos下标的元素

            <实现类>1.ArrayList:查询快----删除快(数组实现---线程安全)

<Vector:数组实现,线程安全,重量级>

                    2.LinkedList:查询慢----删除慢(链表实现)

          /*------------------Sun公司写得Stack不能用-----------*/

          |  class Stack{

          |     private LinkedList list = new LinkedList();

          |      //进栈操做

          |      public void push(Object o){

          |          list.addFirst(o);

          |      }

          |      //出栈操做---(删除头结点--并返回头结点对象)

          |      public Object pop(){

          |          Object o = list.removeFirst(o);

          |          return o;

          |      }

          |  }

          /*------------------Sun公司写得Stack不能用------------*/          

            

        2.Set<Set元素无序,对象内容不能重复>-----

            方法所有继承自Collection接口

                /*----------------------------迭代遍历---------------------*/

                    Iterator it = set.iterator();

                    while(id.hasNext()){

                        Object o  =  it.next();

                        .....//对单一对象进行操做

                    }

                /*----------------------------迭代遍历-------------------*/

            <实现类>1.HashSet:(元素不能重复}(必须覆盖hashCode方法,和equals方法;)

//比较对象是否相同,虚拟机会先比较元素的HashCod,若是其值相等,而后再调用equals方法进行比较.

                                <String 类,Sun公司已经位置写好了hashCode方法>

自定义对象放入HashSet,为了保证元素不重复,须要：

①覆盖hashCode(),保证相同对象返回相同的hashCode,(尽可能)保证不一样对象返回不一样的 int;

②覆盖equals(),保证相同对象,返回true;

                    2.LinkedHashSet(元素不能重复,可是保留元素顺序,);

            <子接口>1. interface SortedSet;//其中的元素不可重复,且通过排序

--<因此其中的对象必须实现Comparable接口,并实现其中的comparableTo方法>

                <实现类> TreeSet //因其中的元素通过排序,因此其中对象须要实现Comparable接口

Student{

public int compareTo(Object o){

//第一种

Student s = (Student)o;

this.name.compareTo(s.name);

//第二种

Student s = (Student)o;

if(this.age>s.age)

return 1;

if(this.age<s.age)

return -1;

return 0;<要比较对象的全部属性,且对象的compareTo()方法返回0时,意味着两个对象相等(equals)>

}

}

    2. interface Map {}---储存键值对<key-value>

键不能够重复,值能够重复

            1.Object get(Object key)//得到键key对应的值

            2.put(Object key,Object value)//将键值对加入Map中,若是元素已经存在,则覆盖原有值

            3.remove(Object key)//删除key对应的键值对

            4.Set keySet();//返回Map中的全部键的Set集合

            5.Collection values();//返回全部元素值的Collection集合

            6.containsKey(Object key)/containsValue(Object value);//是否包含key/value

            7.size();//返回集合中元素的个数

            8.isEmpty();//判断是否为空

            9.clear();//清空集合

            10.entrySet():// 返回键值对的Set集合,其中存放的是Map.Entry,用来遍历键值对

                /*----------------------------Map.Entry-------------------*/ 

interface Map.Entry

1.getKey();//得到键

2.getValue();//得到值

3.setValue();//修改其中的值

                /*----------------------------Map.Entry-------------------*/   

        <实现类>1.HashMap:1.2(其中的元素无顺序,的键不能重复,采用的是hashCode方法,

因此其中的键对象须要覆盖hashCode和equals方法)容许空指针 null 做为键或者值 

2.Hashtable:1.0,线程安全的重量级---/*小写t*/,不容许空指针<面试题,类名区别空指针>

                3.LinkedHashMap:其中的键对象依然不能重复,可是会保留元素的顺序

4.properties:一种map其中的键和值都是字符串类型

        <子接口>SortedMap://其中的元素对键进行了排序,

                    <实现类> TreeMap //其中的键对象须要实现Comparable接口

     3.Collections: //这是个集合类,其中包装了不少对集合经常使用的操做方法,

            (若是要排序,找大小,须要集合中的对象实现Comparable接口);

4.排序:

TreeSet 自动排序 根据排序规则,相同的元素会过滤掉

List    Collections.sort  

要求集合中的对象必须实现Comparable接口,实现compareTo方法

<   返回负数

>   返回正数

==  返回0

注意:compareTo方法和equals方法必须逻辑一致 (compareTo返回0,equals必须返回true)

5.加强循环接口 for--each-----编译器自动将for-each翻译为迭代遍历

6.泛型:为了类型安全.是一个模版编程.实现类型安全的集合;

======================================枚举=================================

enum 

    1.类：这个类的对象是构造好的，不容许构造该类的新对象

关键字：enum

特殊的类 默认是Enum的子类，因此不能再继承别的父类，同时是final类

全部的构造方法必须是私有的---不可能有子类

枚举值：枚举类的对象，也是枚举类中的公开静态常量

2.Enum的方法：

        name()返回该枚举对象对应的枚举值

        ordinal()返回该枚举对象对应枚举值的下标

        枚举类.value()返回全部的枚举值对象---数组

        枚举类中能够定义抽象方法，且方法是留给枚举值实现，不一样的枚举值各有各的实现--匿名内部类

======================================异常处理=================================

1.增长程序的容错性,(当程序运行出现异常的时候,可以良好的运行下去)

异常处理,减小异常的损失

try{

插卡

输入密码,金额2000

银行卡余额-=2000

吐钱2000

}catch(吐钱异常 e){

银行卡余额+=2000

}finally{//不管有没有异常,都能执行<必定会执行>;通常用来释放资源；

try{

退卡

}catch(退卡异常 e2){

System.out.println("请带上你的身份");

}

}

2.异常的分类<Throwable---父类 >

<Throwable>

|--Error 错误严重的底层错误--不可避免,没法处理

|--Exception 异常

|--RuntimeException(运行时异常)的子类 未检查异常 能够避免的--可处理也可不处理(优先考虑避免)

|--非RuntimeException()的子类  已检查异常 不可避免的---必须处理

throw 异常对象(Throwable对象);抛出异常(功能等同于return,使函数返回)

3.处理异常:

1.throws 声明抛出,若是出现这种异常,我就向上抛出;(后面跟的是已检查异常的类名)

2.try{}catch(异常引用 e){} //catch结束后,异常将会被消化处理,程序会正常执行到结束;

//也能够处理未检查异常;若同时捕获,必须先捕获子类异常,后catch父类异常

3.try{}finally{}//利用finally必定执行的特色,在try返回以前,作些操做;

4.方法的覆盖:

子类的方法,不能比父类的方法抛出更多的异常<范围>;

=======================================多线程=================================

1.多线程

1.进程:OS并发的一个任务

2.并发原理:CPU分时间片,多任务交替执行,宏观并行,微观串行

3.线程:在一个进程中,并发执行的一个顺序流程

1.线程3要素:

CPU 

数据 堆空间共享,栈空间独立, 

代码 继承Thread类,覆盖run()；实现Runnable接口,实现run()；

线程启动:

1.继承Thread类

Thread t1 = new ThreadA();//线程对象表明了一个线程

t1.start();//启动一个线程,执行run方法中的代码

2.实现Runnable接口,

Runnable target = new Target();//建立目标对象

Thread t2 = new Thread(target);//建立线程对象

t2.start();

2.线程进入阻塞状态:

等待数据输入;

sleep();休眠<来自Thread类中的一个静态方法;>//Thread.sleep();

3.线程同步:<保护原子操做不被破坏>

当多线程访问同一个对象(临界资源),若是破坏了原子操做,会致使数据的不一致;

关键字: synchronized 同步的----

用法: 1.synchronized(对象o){}//对o加锁的同步代码块

每一个java对象都有一个互斥锁标记,用来分配线程.只有拿到o锁标记的线程,

才能进入对o加锁的同步代码块

 2.方法修饰 同步方法 对 this 加锁的同步代码块

 //只有拿到对象锁标记的线程,才能调用o的同步代码块

每一个对象都有一个锁池,用来存放等待的线程

4.线程死锁

一个线程能够同时拥有多个对象的锁标记<同步带代码块能够嵌套>-------容易形成死锁。

-----------------------哲学家进餐问题-------------------

解决死锁问题:

线程间通讯：waite等待--notify通知。

任何对象都有一个等待队列，用来存放线程。

Object类方法

t1:object.wait() 必须放在对object加锁的同步代码块中。t1会释放其拥有的全部锁标记。同时t1会阻塞在object的等待队列中;

t2:object.notify()/notifyAll()必须放在对object加锁的同步代码块中,从object的等待队列中释放一个/所有线程;

注意:wait和sleep

=====================================I/O框架======================================

1.I/O框架

1.File:表明磁盘上的一个文件或者一个文件夹,

File file = new File("abc/test.txt");//辅助性的类,操做文件不能打开读写

file.操做文件;

createNewFile()//建立一个新文件

mkdir()//建立一个新目录

delete()//删除文件或空目录 

exists()//判断File对象所对象所表明的对象是否存在

getAbsolutePath()//获取文件的绝对路径

getName()//取得名字 

getParent()//获取文件/目录所在的目录

isDirectory()//

isFile()//是不是文件

length()//得到文件的长度

listFiles()//列出目录中的全部内容,

renameTo()//修改文件名为

2.IO---用来JVM与外部数据传输的对象

方向:输入流/输出流

字节单位:字节流/字符流<v> 

功能分类：节点流<真正传输数据>/过滤流<装饰模式>

3.字节流:InputStream/OutputStream<字节流的父类 抽象类,没法建立对象>

1.节点流

<FileInputStream/FileOutputStream>;

int read()/write(): //每次读写一个字节,并将内容返回成int类型,打印的时候,须要转换成char。

read(byte[] bs)/write(byte[] bs)://尝试读满一个数组,返回实际读入的字节数.(独到的数据被装在字节数组中)

read(byte[] bs,int start,int len);

流.close();//流是一种资源,须要关闭

2.过滤流:

1.<DataInputStream/DataOutputStream>(能够读写8中基本类型,和字符串)

----Data流保存数据的方式是采用拆分字节方式,而不是采用文本的方法,

因此保存的dat没法用文本编辑器直接编辑

3.过滤流的使用步骤:

建立节点流   FileOutputStream fout = new FileOutputSteam("test.dat")

封装过滤流   DataOutputStream dout = new DataOutputStream(fout);

读写数据 dout.操做

关闭外层流   dout.close();

4.缓冲流<过滤流(缓冲流)----提升IO的性能---主要输出流>:BufferedXXStream 

1.BufferedInputStream/BufferedOutputStream

注意:缓冲流读写数据最后,须要flush或者关闭外层流,以清空缓冲区,才能将缓冲区的内容读写出去

5.PrintStream<过滤流>缓冲功能,写8中基本类型数据,和字符串,还能写对象(写的是对象的字符串形式toString())

System.out.----out是System类的一个静态属性,out是PrintStream类型的数据

6.PipedInputStream/PipedOutPutStream//管道流,用于线程之间的数据通讯

7.RandomAccessFile://随机文件访问读+写(断点续传) 

 

8.ObjectXXXStream(过滤流)://有Data流功能,带缓冲,还能读写对象

<读写对象:对象须要可序列化>

2.对象序列化,须要实现Serializable接口(标记 接口)

对象的属性被 transient 修饰后,成为临时属性,将不参与序列化;

注意:若是要作对象文件追加的时候,须要先读取全部信息,而后再从新写入,不然 会破坏对象的结束标志

/*---------------------存储对象注意-----------------------*/

问题描述:流对象会记录对象的地址,当对象内容修改以后,再存储的时候,流对象不会再读取新内容

而是将原对象从新存储一遍

解决办法:1.更换一个流对象;

2.从新 new 一个新对象,将原对象克隆至新对象

---实现Cloneable接口,调用Object的clone()方法,克隆一个新对象;

/*---------------------存储对象注意-----------------------*/

                

4.字符流:Reader/Writer----抽象类-字符流父类---更好地解决字符的编码问题

/*----------------乱码问题--------英文不会出现乱码问题-------*/

当编解码不统一的时候,会形成乱码

ASCII 美国 1char -- 1B

ISO 西欧 1char -- 1B

GBK2312/GBK 中国大陆 1char -- 2B

Big5 中国台湾 繁体   中文

Unicode 全球统一

UTF-8 可变长的

UTF-16 java默认的

/*-----------------乱码问题--------英文不会出现乱码问题-------*/

1.节点流:FileReader/FileWriter 得到文件字符流(通常不用)

InputStreamReader/OutputStreamWriter

//桥转换构造方法接受一个XXputStream类型的参数,完成字节流转字符流

<桥转换的步骤:>

建立字节流 //xxputStream

桥转换为字符流------------//InputStreamReader/OutputStreamWriter

在字符流上封装过滤流

读写数据

关闭 外层流

BufferedReader/PrintWriter(BufferedWriter)  //带缓冲的字符流

    5.PrintWriter()//1.5版本替代BufferedWriter(直接用字节流构造一个字符流--不能指定编码格式,采用的是系统默认的编码格式)

PrintWriter是过滤流,(缓冲,8中基本类型<转换为字符串形式,与Data流不一样>,写对象)

也能够是节点流,构造方法能够接受一个文件名或File对象做为参数,

得到一个输出到文件的PrintWriter,采用默认编码

        PrintWriter pw = new PrintWriter("test.txt");

========================================网络编程====================================

1.网络编程

ip：  一台主机在网络中的逻辑地址 MAC  物理地址

端口：一个进程绑定一个端口   标识主机的进程

OSI七层模型 TCP/IP模型

应用

表示 应用 HTTP FTP SMTP

会话

传输 传输 TCP  UDP

网络 网络 IP协议:寻址 路由

数据链路 网络接口

物理

1.网络编程的3要素

IP地址:InetAddress(本地回环地址:127.0.0.1  localhost)

端口号

用于标识进程的逻辑端口

有效端口:0~65535  0~1024系统使用或保留

传输协议

经常使用协议：TCP  UDP

2.UDP用户数据报协议----面向无链接  不可靠(丢包-乱序)

1.特色

1.不须要链接

2.每一个数据报大小限制64k

3.不可靠

4.不须要创建链接，速度快

2.UDP--Socket编程

3.TCP传输控制协议--面向链接  可靠的

1.面向链接

2.必须创建链接,速度慢(三次握手),可靠

客户端Client代码;

Socket s = new Socket("127.0.0.1",8888);//客户端经过Socket对象链接服务器(电话机)

服务器端Server代码:

ServerSocket ss = new ServerSocket(8888);//服务器端建立相应的ServerSocket,绑定8888端口

Socket s = ss.accept();//接受一个客户端呢请求，监听端口,阻塞方法

4.Socket

Socket就是为网络服务提供的一种机制

========================================反射===============================

1.反射---通用编程

1.类对象,类加载

类对象(类加载的产物)------封装了一个类的全部信息<类名  父类  接口  属性  方法  构造方法...---类的信息>

类对象属于哪一个类-----Class类的对象

概念<类对象-----类的对象>

2.得到类对象的方式:

        1.类名.class(也能得到8种基本类型的类对象)

        2.类的对象.getClass();

        3.Class.forName("类名记得加包名");//能够加载对象

//直接使用Class 引用，使用类名.Class得到类对象

Class c1 = HashMap.class;

(Class ic = int.class)//8中简单类型也有类对象

//经过得到对象的类型getClass()；得到类对象

HashMap hashMap = new HashMap();

Class c2 = hashMap.getClass();

//经过类名得到类对象

String className = "java.util.HashMap";//写类全名，不能省略包 名

Class c3 = Class.forName(className);//加载类--得到类对象.

    /* ---本身写的类,在得到类对象的时候,须要加包,即要写类的全名----*/

Objece o = c3.newInstance(c3);

c1.getName();//得到类名<带包的完整类名>

c1.getSimpleName();//得到类名<仅本类名>

c1.getSuperclass();//得到父类的类对象;

Class[] cc = c1.getInterfaces();//返回该该类实现的接口，放在Class数组中

c1.getFields();//得到Field属性对象

Method[] ms = c1.getMethods();//得到类中全部的公开方法对象,包括父类

c1.getDeclaredMethods();//得到本类公开和非公开方法在内的全部方法对象;

Method m = c1.getMethod("put",Object.class,Object.class);//得到一个对应的方法对象

m.getReturnType().getName();

m.invoke(o,参数,参数);//对对象o调用m的无参方法;

3.反射更通用;突破封装限制;

----是用于底层的,不要滥用反射,不安全;

1.标注(JDK 5.0):Annotation----描述代码的代码,给机器看的;

传统的注释:描述代码的文字

格式:@Override

标注是一种类型:<类型:类(class)接口(interface)枚举(enum)标注(annotation)>

1.标记标注:@标注名

2.单值标注:@标注名(属性名=属性值)

3.普通标注(多值标注):@标注名(属性1=值1,属性2=值2...)

1.特例(前提:单值标注,若是属性值为value)"value="能够省略

@标注名(value="hello")-------单值标注的属性名--一般都是value

2.标注定义:Target/Retention

package com.test;

import java.lang.annotation.*;

@Target(value={ElementType.TYPE,ElementType.FIELD,ElementType.METHOD})//决定能标注什么

@Retention(value=RetentionPolicy=RUNTIME)//从编译到类对象生成，一直存在 

public @interface Test {//注意标注定义的格式

String value();//标注 属性的定义---既是属性也是方法

String test()default "Liucy"//有默认值得属性

}

3.标注的使用:

package com.test;

@Test

public class TestAnnotation {

@Test

private String name;

public static void main(String[] args) {

}

@Test

public String toString(){

return null;

}

}

4.标注的反射使用:

================================设计模式=============================

1.设计模式

1.单例模式:

        /*静态属性  建立类的一个对象

          静态方法  返回类的对象(静态属性)

          构造方法私有*/

        /*------------------单例模式的恶汉式实现-----------------------*/

        class MyClass{

            private static instance = new MyClass();//静态属性  建立对象

            public static MyClass getInstance(){

                return instance;

            }//静态方法  返回对象

            private MyClass(){}//构造方法私有化

        }

        /*------------单例模式的懒汉式实现------节约内存---影响效率-----*/

        class MyClass{

            private static instance;//静态属性  建立对象

            public static synchronized MyClass getInstance(){

            if(instance == null) instance = new MyClass();

                return instance;

            }//静态方法  返回对象

            private MyClass(){}//构造方法私有化

        }

     2.工厂模式---减小硬编码