JAVA基础知识总结

第一章  JAVA的概述
1. JAVA的特点和优势：面向对象，健壮性，跨平台，并发性(多线程) / 
     java的虚拟机(JVM).垃圾回收机制(GC)
2. JAVA程序的开发三部曲
        编写java源代码->编译java代码(.class文件  (javac   xxx.java) )->执行程序(java  xxx)   / javadoc   xxx.java

第二章 JAVA的基本语法
1.数据类型(8大基本数据类型)：整数型 byte(1字节)    short(2)   int(4)   long(8) 默认值都为0
   浮点型 float(4)默认值为0.0f      double(8)   默认值为0.0    
   字符型 char(2) 默认值为'\u0000'   在UTF-16中表示为0的字符 
   布尔型 boolean(不确定)  默认值为false
2.变量   
 java中为变量内存分配(对指针封装了) 在堆中错数据 在堆栈中存引用(地址)
 标识符  数字，字母，下划线，"$"  ,不能以数字开头。
3.数据类型之间的转换
 自动类型转换(隐式转换)：  小范围向大范围转换
 强制类型转换(显示转换)：  double d=1.25;  float f=(float) ;
 (不能在布尔型和其他数字类型之间转换)
4. 运算符  
 算术运算符  +    -   *   /    %   ++  --
 赋值运算符   =   +=   -=   *=  /=   %= 
 关系运算符 > <  >=   <=  !=  ==
 逻辑运算符&& ||  !  &   |  ^
 位运算符&   |  ^    ~    <<   >>    >>>
 
5. 表达式  
 表达式的优先级（14级)
6.控制流语句
 判断(条件)语句 ：if    if...else     switch...case
 循环语句：while    do...while    for
 跳转语句：break   continue
7.数组  
 声明： 数据类型[ ] 数组名    /数据类型  数组名[ ]
 创建：数组名=new 数据类型 [ 长度]   
 数据类型[ ] 数组名=new   数据类型 [ 长度]   / 数据类型[ ] 数组名={  数据  }
 数组名在堆栈中  数据在堆中
 
 多维数组：数据类型[ ][ ] 数组名=new 数据类型 [ 长度][长度]   
 对象数组：对象名[ ] 变量名=new 对象名[长度]

第三章 面向对象

1. OOP面向对象
 封装性：将一个对象的属性和方法封装以来
 类：具有相同属性和方法的集合体  属性，方法，构造方法
 对象：一个类得实例
 对象在内存中的存储方式：Person person=new Person()   变量名person存在栈内存中，作为一个对象

的引用，指向一个对象，这个person对象存在堆内存中。
 this关键字：可以看做是一个变量，它的值就是当前对象的引用，它指向对象本身。
 权限控制：public  公共的
  protected    受保护的(父子类中)
  _________    包权限(在同一包里)
  private 私有的
  
 
 继承性：用已经存在的类构建出一个或多个子类的机制(java只能单继承)
  构造函数不能被继承，。
  在创建子类的时候会自动先创建分类的实例，再在这个父类实例上添加子类特有的属性和方法。
 super关键字：在子类中用super()显示的调用父类的构造方法
 static 关键字：表示静态的，它所修饰的属性和方法都是属于类得，可以直接用类名去调用。 
 final关键字：最终的，它修饰的变量的值不能变，用static final修饰的变量在声明是就赋值，final修饰的

属性必须在构造器结束之前赋值。final修饰的方法不能被重写，final修饰的类不能被继承。 
 
 
 多态性：条件：1.在继承机制下，2.有方法的重写 3.父类引用指向子类对象(将父类实例转成子类 类型

用instanceof 判断两个对象是否是同一类型    if("引用型变量" instanceof"类型")
  多态能使得同一函数在不同类中有不同的实现。

 方法的重载和重写：
  重载：方法名相同，参数不同(个数，顺序，类型)，返回值可以不同，在同一个类中。
  重写：方法的签名相同(方法名相同，参数相同，返回值相同)  在父子类中。
 
 对象的类型转换：强制向下转型：将父类转成子类(当父类对象变量指向的是父类型，不能转换.)
   向上转型：将子类转成父类(父类引用指向子类对象)
2.抽象类(abstract)
 含有抽象方法的类就是抽象类，(也可以没有抽象方法)不能new，但可以引用子类对象。
 
3.接口(interface)
 所有的方法都是抽象方法，(可以只定义常量，没有任何方法)，
 接口不是类，在接口内没有构造方法。不能new ，但也可以实现多态，接口的引用指向子类对象
 可以被其他类实现(imlenments),可以实现多个接口。接口也可以被继承。
4.适配器：实现接口中的一部分方法。

5.嵌套类(nested class)：在类中声明的类，也叫内部类(inner class).
 内部类可以访问创建它的外部类的属型和方法；不能为同一包中其他类所见，可以更高的封装。
 内部类可以看做外部类的一个成员，和外部类的成员变量，成员方法并列存在。
 内部类分为：局部内部类：在外部类的方法体内声明的内部类。
     匿名内部类：没有声明名称的内部类，直接使用。
 静态嵌套类：用static修饰的嵌套类。相当于外部声明的一个类，它只能访问外部类中的静态成员。
   
第四章  JAVA异常

1.异常(Exception)：运行时的错误，逻辑问题。
   java异常的层次结构
    Object

    Throwable
  error(JVM系统处理)     exception(可抛出的异常)
 
     runtimeException (可以不处理)       not 

RuntimeException(需要处理，会有语法错误，不能通过编译) 
2. 异常的处理:运行时如出项异常，会自动生成一个异常类的对象，将这个对象提交给java运行时系统，这叫抛出异常

；由java运行时系统接受这个对象，会再抛出异常附近找到能处理这个异常的代码，把这个异常交给这个代码块，这叫

捕获异常；最后由代码块处理这个异常，这叫处理异常。
 try {     (try不能单独存在，后面必须有catch,或者finally)
  捕获异常 
 }catch(异常类型 e){
  处理异常
 } catch(异常类型 e){
  处理异常
 } finally{
  一定执行的代码
 } 
       
3.异常的手动抛出：throw和throws
4.自定义异常
5.断言
 assert  表达式1；若1为true，继续执行，为false 则抛出异常，
 assert 表达式1：表达式2；如1为true，2不执行，程序继续执行；如1为false，2就为一个异常对象，并

抛出该对象。、

第五章  JAVA API(应用编程接口)
 
1.包： java.lang   java常用包sun定义;javax扩展包sun定义;org第三方包;
 java.util
 java.io
 java.sql
 java.net
 java.swing
 java.math
2 java.long(基础包)
 主要的类：基类：Object
  包装类：八种基本数据类型的包装（装箱，拆箱）
  数学类：Math类 
  字符处理类：String，StringBuffer
  反射类：Class
  系统类：System
  运行时环境类：Runtime
 主要的方法：equals()    hashCode()    toString()    getClass()   finalize()资源回收
     字符串的比较： equals()比字符串的值，“==”比较地址
  String方法：  indexof()    chatAt()   split()     trim()
  
  StringBuffer的方法：append()     insert()   toString()转换为字符串输出 
    reverse()反转字符串   replace()
3.java.util(工具包)
 主要的类：   主要方法
 Random(产生随机数)  Random();      nextInt(n),nextDouble(),
 Scanner(扫描输入文本) Scanner scanner=new Scanner(System.in)
    int i=scanner.nextInt();读取一个整数

 Arrays操作数组的类   sort(int[ ]  a)快速排序的方法   copyof()
 
 Data类          new Data();   getTime()   toString()
 Calendar抽象类  Calendar.getInstance()获得实例
 这个对象之间的转换  Data转Calendar      Data data=new Data();Calendar

cal=Calendar.getIntance();cal.setTime(data);
    Calendar转Data      Calendar cal=Calendar.getIntance();   Data 

date=cal.getTime();
 国家化相关的类Locale;  MessageFormat
 日期格式化的类DataFormat   
 数字格式化的类NumberFormat(抽象类)
 

 
 集合框架：用来存数据的容器，优于数组，可变长，数据结构，算法
 4个部分组成  
    collection接口(一次存一个)
 
 list接口(动态数组，有序可重复)    set接口(无序不可重复，散列码)
ArrayList  (优于查)   LinkList(优于删，添)     Vector  HashSet    TreeSet
 基本方法：size()  get()  add()     iterator()   hasnext()  next()

  Map接口(一次存一对  ，键值对的形式)
 HashMap(存对象)  Hashtable properties(存字符)
 基本方法：size() put(k,v)    get(k)    keyset()

 排序接口：comparable comparator
 工具类：collections

 迭代器：Iterator可以对集合进行迭代

4.正则表达式
 4.1语法：限定符：“ * ”  0或多个    “  + ” 1或多个   “ ？”  0或1个   {n}  n次   {n,} 至少n次   {n,m}  n到m次
                    选择符:“ |  ”  两个中的任意一个
  字符匹配集:[abc ]任意一个；[^abc]非abc的字符；[a-z] ;[ ^a-z];   "  . " 匹配除“\n”外所有的单

个字符；      
   \d  数字字符;\D非数字字符;
   \w 任何单个字符，包含下划线;\W 任何非单个字符;
   \s 空白字符"空格，制表符，换页符";\S 任何非空白符；
  定位符： ^  字符串开始的位置
   $结尾的位置
   \b 匹配一个单词边界  er\b   never;
   \B 非子边界匹配
 4.2正则表达式的使用
  java.util.regex     Pattern和Matcher
  构造一个模式：Pattern p=Pattern.compile("正则表达式")
  建造一个匹配器：Matcher m=p.matcher(输入的字符串)；
  进行判断：boolean  b=m.matches("regex",输入的字符串 )
  Pattern.compile(regex).matcher(input).matches();
 4.3 常用的正则表达式实例
  中文名：Pattern.matches("[\\u4E00-\\u9FA5]+",cn)   （cn为传进来的参数）
  邮箱地址："[a-zA-Z0-9]+@[a-zA-Z0-9]+\\.[a-zA-Z0-9]+"
  手机号："^1[3568]\\d{6}"
  邮政编码："\\d{6}"
  

5.java.io( 包括文件和流的操作)
 5.1   文件(File)        new    File(String filename);
  属性方法....
  创建： 目录：mkDir()   mkDirs()
   文件：createNewFile()
    isExists()是否存在
  删除: file.delete()
  查询的方法  (循环递归目录结构)

 5.2  IO流  相当于一个管道，用来传输数据。
 4中抽象流类
   输入  输出
 字节  InputStream outPutStream

 字符  Reader  Writer
 
 
 文件流：File+4中抽象类流
 缓冲流：Buffered+4种抽象流类 (提高数据的读写速度，先创建一个内部缓存区数组，将数据先放在缓冲

区)
 转换流：InputStreamReader  OutputSreamWriter  (字节流和字符流之间转换)
 数据流：DataInputStream   DateOutputStream   (用来读取和写出基本数据类型的数据)
 打印流：PrintStream   PrintWriter (将基本数据类型数据，字符串，对象数据格式化成字符串输

出)
 对象流：ObjectInputStream   ObjectOutputStream 
 随即存储文件流:RandAccessFile      可读可写  任何位置

 基本方法：read()   close()   read(byte[] start,len)    flush( )   write();
     

第六章  多线程

6.1 进程的概念：每个独立的程序在计算机上的一次执行活动。(有独立的代码和数据空间)
       线程的概念：一个进程由多个线程组成，线程就是进程内部的一个执行路径，一个程序在同一时间内可以执行多个

线程，那么程序就是支持多线程的。(共享相同的代码和数据空间)
6.2.线程的创建和启动   两种方法
 第一种：继承Thread类，并重写run()方法
  Thread  thread=new Thread();
  thread.start();
 
 第二种：实现Runnable接口，重写run()方法
  MyRunnable  mr=new MyRunnable();
  Thread thread=new Thread(mr);
  thread.start();
 
6.3  线程的状态和生命周期
 
 

 新建线程---start()------>就绪状态-------(系统调度)--------->运行状态------run()-------->死亡状态
 运行状态--------sleep()  jion() wait()----------->睡眠，挂起--------超过时间--------------->就绪
 运行状态----------wait()  yeild()   jion() ------------->等待状态-------------notify()  notifyAll()---->就绪
 运行状态--------------------对象锁------------------------->阻塞状态------------------解锁----------->就绪

 thread.sleep(1000) 睡眠一秒
 yeild() 暂停当前的线程，并执行其他线程。
 join()等待线程终止。自己先用。
 
 后台线程：setDaemon()  守护线程  精灵线程
 线程的优先级：1-10级thread.setPriority(Thread.常量) 

6.4 线程同步：同一时刻只允许一个线程操作资源。关键字：synchronized放在方法的声明中。
  生产消费者问题。火车售票问题。

第七章  网络编程

7.1    HTTP协议：一种无状态的基于请求和响应的应用于Internet协议规则。B/S
          TCP/IP分层(对应的协议)：应用层(HTTP,FTP,SMTP,TEMNET)，传输层(TCP,UDP)，网络层(IP,ICMP,ARP)

，网络接口层。
7.2  java.net  网络包
 类：InetAddress (封装了地址对象的类)用来表示IP地址。不能new一个实例 要通过静态工厂获得实例。
      InetAddress   inet=InetAddress .getByName(String  host主机名)
  URL:封装了统一资源定位符的类，只能读URL信息
  标准的url：协议名://地址:端口/资源名
  url=new URL("地址")创建URL对象
  URLConnection   connection=url.openConnection() 获得URLConnection对象,可读

写url信息。
  connection.connect()打开这个url的连接 可以用流到这个地址上读取资源
  in=new BufferedRead(new  InputStreamReader(connection.getInputStream()))获得输

入流，读取资源
     

7.2   socket(套接字)编程
 TCP:端到端的字节流通信协议，是面向连接的，要连接通了才开始发送数据，安全可靠，但是效率低。
 服务器端套接字(ServerSocket)
  创建ServerSocket(端口号) serverSocket=new ServerSocket(1234);
  通过accept() 获取一个Socket对象 s=serverSocket.accept();
  通过Socket获取inputStream和outputStream  s.getInputStream()  /  

s.getOutputStream()
  
  输入流：BufferedRead  in=new BufferedRead(new 

InputStreamReader(s.getInputStream()))
  打印流：PrintWriter out=new PrintWriter(new

OutputStreamWriter(s.getOutputStream()))

 客户端套接字(Socket)  
  创建Socket("ip",端口号) Socket  s1=new Socket("192.168.100.105",1234);
  
  通过Socket获取inputStream和outputStream  s1.getInputStream()  /  

s1.getOutputStream()

 UDP：提供一种发送原IP数据报的方法，发送时无需连接好，只要将目的地记录在数据包中，所以不安全

。
  发送端： 创建一个要发送的数据包：DatagamPacket  dg=new DatagamPacket(ip,接受

端的端口，数据内容，长度);
   创建发送数据包的Socket,通过指定的端口来发送  DatagramSocket  s  = new 

DatagramSocket(自己本身的端口);
   发送：s.send(dg);
  接收端:  创建一个接受的数据包：DatagamPacket  dg=new DatagamPacket(buf,  

buf.length);  
   创建接受数据包的Socket,通过指定的端口来接受  DatagramSocket  s  = new 

DatagramSocket(自己本身的端口);
   接受数据：while(true){
     s.receive(dg);//在收到数据前一直处于阻塞
     
     String content=new

String(dg.getData(),dg.getOffset(),dg.getLength());//用这三个方法访问刚刚接收到的数据
     System.out.println(content);
    }

第八章   JAVA图形用户界面编程(GUI)

开发环境:eclipse+swt插件
SWT事件模型：事件源---->监听器------------>处理
 运用内部类
 

第九章  反射和注解

1.反射机制：运行中的java程序对自身的检查，(运行时类得一种自省的机制)
 作用： 在运行时判断任意一个对象属于哪个类
  在运行时构造任何一个类得对象
  在运行时判断任意一个对象的成员变量和方法
  在运行时调用任意一个对象的方法，通过反射甚至可以调用私有的方法
  生产动态代理
 所有的类：Class:Class类得实例表示正在运行的java程序中的类和接口
  Field：封装了反射类的属性的类
  Constructor：封装了反射类的构造方法的类
  Mehtod：封装了反射类的方法的类
  Array：
 获取Class对象：三种方法
   1：用Object 的getClass()方法获得Class对象 MyObject  my； Class

c1=my.getClass();
   2:   用Class类得forName()静态方法获得与字符串对应的Class对象    Class

c2=Class.forName("java.lang.String");
   3:   用类型名.class获取      Class  c3=Manager.class;
 方法：getName()  getField()   getMethods()    getAnnotations()
 创建这个Class对象所表示的类得一个新实例：   
   1:使用无参的构造方法创建    注意：如果指定名称的类没有无参的构造函数，则在调

用这个方法是会报错。
    Class c2=Class.forName("java.lang.String");      
    String  str=c2.newInstance()
   2：使用带参的构造方法创建
    加载指定名称的类，获取Class对象：Class

c2=Class.forName("java.lang.Date");
     获取具有指定参数类型的构造方法： Constructor  constructor

=c2.getConstructor(指定参数类型 int.class);
    通过 Constructor对象的newInstance方法来创建实例  Date  date=

(Date) constructor.newInstance(1234);
   
 

2.注解(Annotation)
 元数据：用于描述数据的数据(XML--->DTD/Schema)
 注解：java源代码的元数据    
 语法： @注解的名称

 JDK内置的注解(预定义注解)： @Override  重写方法  //注解: 在编译时起作用    代码检查
    @Deprecated 指明方法过时
    @SuppressWarnings 抑制编译器警告

 自定义注解：语法   @Documented//生成文档
   

@Target({ElementType.TYPE,ElementType.METHOD,ElementType.FIELD})//表示注释的位置
   @Retention(RetentionPolicy.RUNTIME)  //运行的时机
   public @interface HelloAnnotation {
    public String name()default "先生/女士";   //注解的一个成员，属性 
   }

3.代理机制