J2SE基础知识小结

2017-04-04  本文已影响0人  鸩羽千夜92

一、基本语法

1.1 关键字

    定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
    特点：关键字中所有字母都为小写

    用于定义数据类型的关键字
    class 、interface 、enum、byte、short、int、long、float、double、char、boolean、void
    
    用于定义数据类型值的关键字
    true、false、null

    用于定义流程控制的关键字
    if else switch case default while do for break continue return

    用于定义访问权限修饰符的关键字
    private、protected、public

    用于定义类，函数，变量修饰符的关键字
    abstract、final、static、synchronized

    用于定义类与类之间关系的关键字
    extends、implements

    用于定义建立实例及引用实例，判断实例的关键字
    new 、this、super、instanceof

    用于异常处理的关键字
    try、catch、finally、throw、throws

    用于包的关键字
    package 、import

    其他修饰符关键字
    native、strictfp、transient、volatile、assert

1.2 标识符

    标识符：
        Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
        凡是自己可以起名字的地方都叫标识符。
    定义合法标识符规则：
        由26个英文字母大小写，0-9 ，_或 $ 组成  
        数字不可以开头。
        不可以使用关键字和保留字，但能包含关键字和保留字。
        Java中严格区分大小写，长度无限制。
        标识符不能包含空格。
    注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
    Java中的名称命名规范：
    包名：多单词组成时所有字母都小写：xxxyyyzzz
    类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
    变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
    常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

1.3 变 量

        内存中的一个存储区域
        该区域有自己的名称（变量名）和类型（数据类型）
        Java中每个变量必须先声明，后使用
        该区域的数据可以在同一类型范围内不断变化
      使用变量注意：
        变量的作用域：一对{ }之间有效    
      初始化值
        定义变量的格式：数据类型  变量名  =  初始化值
      变量是通过使用变量名来访问这块区域的

          变量分基本数据类型(byte,short,int,long,float,double,char,boolean)
                引用数据类型(类class,接口interface,数组)两种。
- 按声明的位置的不同 
          
           在方法体外，类体内声明的变量称为成员变量。
           在方法体内部声明的变量称为局部变量。
           变量分成员变量和局部变量两种。
                成员变量：【实例变量(不以static修饰)和类变量(以static修饰)】
                局部变量：【形参(方法签名中定义的变量)和方法局部变量(在方法内定义)和代码块局部变量(在代码块内定义)】
        注意：二者在初始化值方面的异同:
             同：都有生命周期      
             异：局部变量除形参外，需显式初始化  

        Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。
        java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’
        byte (1字节=8bit) 
        short(2字节)
        int  (4字节)
        long (8字节)

1.4运算符

    运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
    算术运算符
    赋值运算符
    比较运算符（关系运算符）
    逻辑运算符
    位运算符
    三元运算符

        算符              运算                           范例                     结果
         +               正号                                            +3               3
         -               负号                             b=4; -b                       -4
         +               加                          5+5                       10
         -               减                          6-4                       2
         *               乘                              3*4                       12
         /               除                              5/5                       1
         %               取模                         7%5                       2    
         ++              自增（前）：先运算后取值           a=2;b=++a;              a=3;b=3
         ++              自增（后）：先取值后运算         a=2;b=a++;                a=3;b=2
         --              自减（前）：先运算后取值           a=2;b=--a               a=1;b=1
         --              自减（后）：先取值后运算           a=2;b=a--               a=1;b=2
         +               字符串相加                      “He”+”llo”              “Hello”

    算术运算符的注意问题
        如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。 但被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。

        对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。 
              例如：int x=3510;x=x/1000*1000;  x的结果是？
        
        “+”除字符串相加功能外，还能把非字符串转换成字符串.例如：System.out.println("5+5="+5+5); //打印结果是？
        
        以下二者的区别：
        System.out.println('*' + '\t' +'*');
        System.out.println("*" + '\t' +'*');    

       运算符          运算                  范例                                结果                      
        ==              相等于              4==3                                false                               
        !=              不等于              4!=3                                true
        <               小于                  4<3                                  false      
        >               大于                  4>3                                true
        <=              小于等于              4<=3                               false      
        >=              大于等于              4>=3                                true      
        instanceof      检查是否是类的对象     “Hello”  instanceof  String        true

        比较运算符的结果都是boolean型，也就是要么是true，要么是false。
        比较运算符“==”不能误写成“=” 。

        a       b       a&b     a|b     !a      a^b     a&&b    a||b     
            
        true    true    true    true    false   false   true     true
        true    false   false   true    false   true    false    true   
        false   true    false   true    true    true    false    true
        false   false   false   false   true    false   false    false

        逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。
        “&”和“&&”的区别：
        单&时，左边无论真假，右边都进行运算；
        双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
        “|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。
        异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。
        理解：异或，追求的是“异”!

1.5 程序流程控制

1.6 数组

数组是多个相同类型数据的组合，实现对这些数据的统一管理
数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型
数组属引用类型，数组型数据是对象(object)，数组中的每个元素相当于该对象的成员变量

        定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；

        数组元素的引用方式：数组名[数组元素下标]
            数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];
            数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 —>n-1；如int a[]=new int[3];  可引用的数组元素为a[0]、a[1]、a[2]

        每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长度(元素个数)
            数组一旦初始化，其长度是不可变的

四种访问权限修饰符

 Java权限修饰符public、protected、private置于类的成员定义前，用来限定对象对该类成员的访问权限。

    修饰符               类内部        同一个包       子类      任何地方
    private             Yes
    default(缺省)       Yes           Yes
    protected           Yes         Yes           Yes
    public              Yes         Yes           Yes       Yes

    对于class的权限修饰只可以用public和default(缺省)。
    public类可以在任意地方被访问。
    default类只可以被同一个包内部的类访问。

二、面向对象编程

主函数：

public static void main(String[] args){};
是一个特殊的函数。作为程序的入口，可以被jvm调用。
主函数的定义：
public：代表着该函数访问权限是最大的。

static：代表主函数随着类的加载就已经存在了。

void：主函数没有具体的返回值。

main：不是关键字，但是是一个特殊的单词，可以被jvm识别。

（String[] arr）:函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的是数组。

主函数是固定格式的：jvm识别。

jvm在调用主函数时，传入的是new String[0];

类、对象、属性、方法

类：类似于生活中的“类别”，是对事物抽象的描述。
对象：是类具体的存在。
属性：绝大部分在生活中是使用“名词”来描述的，可以使用值量化的
方法：在生活中表现为“动词”的，是由一系列的行为构成的，是对行为模式的描述
public class Person {
    String name;
    int height;
    float weight;
    int gender;

    void run() {}
    void eat() {}
    void sleep() {}

}

成员变量与局部变量

成员变量也称实例变量 
成员变量作用于整个类中，存在堆内存中
局部变量作用于函数中，或者语句中，存在栈内存中

四个关键字（this,super,static,final ）

面向对象三大特性（封装，继承，多态）

两大抽象(抽象类和接口)

重载(Overload)与重写(Override)

四个内部类

    成员内部类
    静态(成员)内部类
    局部内部类
    匿名内部类

异常

是什么？是对问题的描述。将问题进行对象的封装。

    异常体系：
        Throwable
            |--Error
            |--Exception
                |--RuntimeException
    
    异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性。
                    也就是说可以被throw和throws关键字所操作。
                    只有异常体系具备这个特点。

线程

Java中的ApI

String类

        字符串是一个特殊的对象
        字符串是一个常量
        字符串一旦初始化就不可改变
        没有子类
        
        String s1 ="abc";
        String s2 =new String("abc")
        String s3 ="abc";       
    
        System.out.println(s1==s2);         //false 
        System.out.println(s1==s3);         //true
        System.out.println(s1.equals(s2));  //true  判断字符串是否相同
        
        //s1和s2有什么区别？
        //s1在内存中有一个对象
        //s2在内存中有两个对象

基本数据类型对象包装类。

byte    Byte
short   short
int     Integer
long    Long
boolean Boolean
float   Float
double  Double
char    Character



基本数据类型对象包装类的最常见作用，
就是用于基本数据类型和字符串类型之间做转换

集合类

1. 为什么出现集合类？

    面想对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

2. 数组和集合类同是容器，有何不同

    数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。
    数组中可以存储基本数据类型，集合只能存储对象。

3. 集合的特点

集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

集合框架

Collection

    |--List:元素是有序的，元素可以重复。因为该集合体系有索引。
        |--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
        |--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
        |--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。


    |--Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。、
    |--HashSet:底层数据结构是哈希表。是线程不安全的。不同步。
            HashSet是如何保证元素唯一性的呢？
            是通过元素的两个方法，hashCode和equals来完成。
            如果元素的HashCode值相同，才会判断equals是否为true。
            如果元素的hashcode值不同，不会调用equals。

            注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。


    |--TreeSet：可以对Set集合中的元素进行排序。
                底层数据结构是二叉树。
                保证元素唯一性的依据：
                compareTo方法return 0.

                TreeSet排序的第一种方式：让元素自身具备比较性。
                元素需要实现Comparable接口，覆盖compareTo方法。
                也种方式也成为元素的自然顺序，或者叫做默认顺序。

                TreeSet的第二种排序方式。
                当元素自身不具备比较性时，或者具备的比较性不是所需要的。
                这时就需要让集合自身具备比较性。
                在集合初始化时，就有了比较方式。

Set集合的功能和Collection是一致的。

什么是迭代器呢？

    其实就是集合的取出元素的方式。
    如同抓娃娃游戏机中的夹子。

    迭代器是取出方式，会直接访问集合中的元素。
    所以将迭代器通过内部类的形式来进行描述。
    通过容器的iterator()方法获取该内部类的对象。

泛型

    泛型：JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。
    
    好处
    1.将运行时期出现问题ClassCastException，转移到了编译时期。，
        方便于程序员解决问题。让运行时问题减少，安全。，
    
    2，避免了强制转换麻烦。
    
    
    泛型格式：通过<>来定义要操作的引用数据类型。
    
    在使用java提供的对象时，什么时候写泛型呢？
    
    通常在集合框架中很常见，
    只要见到<>就要定义泛型。
    
    其实<> 就是用来接收类型的。
    
    当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

    //泛型类。
    什么时候定义泛型类？
    当类中要操作的引用数据类型不确定的时候，
    早期定义Object来完成扩展。
    现在定义泛型来完成扩展。

    //泛型类定义的泛型，在整个类中有效。如果被方法使用，
    //那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
    //为了让不同方法可以操作不同类型，而且类型还不确定。
    //那么可以将泛型定义在方法上。
    
    特殊之处：
    静态方法不可以访问类上定义的泛型。
    如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

    ? 通配符。也可以理解为占位符。
    泛型的限定；
    ？ extends E: 可以接收E类型或者E的子类型。上限。
    ？ super E: 可以接收E类型或者E的父类型。下限

集合框架的工具类。

Collections:集合框架的工具类。里面定义的都是静态方法。

Runtime对象

该类并没有提供构造函数。
说明不可以new对象。那么会直接想到该类中的方法都是静态的。
发现该类中还有非静态方法。
说明该类肯定会提供了方法获取本类对象。而且该方法是静态的，并返回值类型是本类类型。

由这个特点可以看出该类使用了单例设计模式完成。

IO(Input Output)流

流常用基类

    字节流的抽象基类：
        inputStream, OutputStream。
    字符流的抽象基类：
        Reader,Writer。
    注：由这四个类派生出来的之类名称都是以其父类名作为之类名的后缀。
        如：InputStream的子类FileInputSteam。
        如：Reader的子类FileReader。

字符流的特点

    既然IO流是用于操作数据的，
    那么数据的最常见体现形式是：文件。
    那么先以操作文件为主来演示。
    找到一个专门用于操作文件的Writer子类对象。FileWriter。
    后缀名是父类名。 前缀名是该流对象的功能。

flush和close的区别：

    flush刷新后，流可以继续使用，它是刷新流中的数据
    close刷新后，会将流关闭。

    需求:在硬盘上，创建一个文件并写入一些文字数据。
     //创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。
     //而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。
    //其实该步就是在明确数据要存放的目的地。
     FileWriter fw = new FileWriter("demo.txt");
    //调用write方法，将字符串写入到流中。
    fw.write("abcde");
    //刷新流对象中的缓冲中的数据。
    //将数据刷到目的地中。
    //fw.flush();
    //关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。
    //将数据刷到目的地中。
    //和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。
     fw.close();

IO的异常处理方式。

public static void main(String[] args) {

    FileWriter fw = null;
    try {
        fw = new FileWriter("demo.txt");
        fw.write("helloworld");
        fw.flush();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (fw != null)
                fw.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

IO文件的续写

//传递一个true参数，代表不覆盖已有文件。并在已有文件的末尾处进行数据续写
 \r\n表示换行
FileWriter fw=new FileWriter("demo.txt",true);

IO读文件读取

单字符读取：

    FileReader fr =new FileReader("d:\\demo.txt");
        int ch=0;
        while((ch=fr.read())!=-1){
            System.out.println((char)ch);
        }
          fr.close();
        }

批量字符读取：

    FileReader fr = new FileReader("d:\\demo.txt");
         char[] buff = new char[1024];
        int num;
         while ((num = fr.read(buff)) != -1) {
         System.out.println(new String(buff, 0, num));// buff数组，0表示从什么位置开始，
                                                                //num表示读几个
            }
            fr.close();

文本文件复制：

    原理：其实就是将C盘下的文件数据存储到D盘的一个文件中。
    步骤：
        1，在D盘创建一个文件。用于存储C盘文件中的数据。
        2，定义读取流和C盘文件关联。
        3，通过不断的读写完成数据存储。
        4，关闭资源。

字符流的缓冲区：

    缓冲区的出现提高了对数据的读写效率
        对应类：BufferedWriter
               BufferedReader
    缓冲区的出现是为了提高流的操作效率而出现的。
    所以在创建缓冲区之前，必须要先有流对象。
    该缓冲区中提供了一个跨平台的换行符。newLine();

    字符读取流缓冲区：
    该缓冲区提供了一个一次读一行的方法 readLine，方便于对文本数据的获取。
    当返回null时，表示读到文件末尾。

字节流：

    InputStream(读)
    OutPutStraeam(写)

    字节流：
    FileInputStream
    FileOutputStream

    BufferedInputStream
    BufferedOutputStream



    通过刚才的键盘录入一行数据并打印其大写，发现其实就是读一行数据的原理。
    也就是readLine方法。

    能不能直接使用readLine方法来完成键盘录入的一行数据的读取呢？


    readLine方法是字符流BufferedReader类中的方法。

    而键盘录入的read方法是字节流InputStream的方法。
    
    那么能不能将字节流转成字符流在使用字符流缓冲去的readLine方法呢？

File

    File类常见方法：
        1，创建。
        boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
                        和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。

            boolean mkdir():创建文件夹。
            boolean mkdirs():创建多级文件夹。
        2，删除。
            boolean delete()：删除失败返回false。如果文件正在被使用，则删除不了返回falsel。
            void deleteOnExit();在程序退出时删除指定文件。


        3，判断。
            boolean exists() :文件是否存在.
            isFile():
            isDirectory();
            isHidden();
            isAbsolute();

        4，获取信息。
            getName():
            getPath():
            getParent():

            getAbsolutePath() 
            long lastModified() 
            long length()

网络编程

网络通讯要素

上一篇下一篇

猜你喜欢

热点阅读