java基础回顾 - JAVA学习网

第一章：java入门

　　了解java，安装jdk、jre，svn，maven

第二章：java基础语法

　　1.变量的定义：权限修饰符（public、protected、default、private）修饰符（static、final）类型（类名）变量名（标识符：由数字、字母、下划线、$组成，且数字不能开头）；

private static fianl String SUCCESSCODE="1";

　　2.方法的定义：权限修饰符（public、protected、default、private）修饰符（static、final）返回值类型（void：无返回值）方法名（类型参数1，类型参数2）{...... }

public static void main(String[] args){
           System.out.println("我是主函数");
}

　　3.基础语法：if、else、for、while、switch case、do while

if("a".equals("a")){
     Systemout.println("a等于a");           
} 

for(int i=0; i<100; i++){
    System.out.println("第："+i+1+"次循环");
}

while(true){
    System.outprintln("我是死循环");
}   

switch(n){
     case 1:
        System.out.println("如果n等于1则我被输出");
        break;//跳出选择分支，不再执行下面的case
     case 2:
        Systemout.println("如果n等于2则我被输出");
        break;
     default:
        System.out.println("如果n不等于任何case则默认我被执行")
}        

do{
    System.out.println("我先执行一次，再判断条件成不成立");   
}while(条件表达式);

4.java功能性关键字：this、super、continue、break、return、synchronized

　　this：代表当前调用本方法的对象

　　super：代表父类对象

　　continue：结束本次循环

　　break：结束循环体

　　return：结束方法，当方法为无返回值时，用return结束方法，当有返回值时，需要返回一个值如 return 0；（返回类型为int、Integer）

　　synchronized：同步

第三章：面向对象（特征：封装、继承、多态、抽象）

　　封装：将数据以对象属性的形式封装到一个对象中，比如数据库的一个表的所有字段都可以用java的对象进行封装

　　继承：子类可以父类所有方法和属性，包括private的，但不能继承被final修饰的方法；被private修饰的方法不能被访问而已

　　　关于子类能继承父类private的属性的解释：父类属性一般都是private的，但是可以通过getter、setter方法进行访问，子类对象也可以通过getter、setter方法访问父类的属性，所以是继承了父类的private的属性

　　多态：父类的引用指向子类的实例，编译时当成父类对象，但实际运行时则为实际具体对象

　　抽象：任何事物都可以被抽象为一个类，类具有公共的属性和方法

　　实体类对象只是用来封装数据用的，且最小属性都是由java本身的类型组成

　　java8大基本类型：short、int、long、float、double、byte、char、boolean 对应的包装类Short、Integer、Float、Double、Byte、Character、Boolean

　基本类型和引用类型的区别：基本类型其本质不是对象，而引用类型是以对象的形式表现，可以调用方法

第四章：异常（Exception）

　　自定义异常：继承Exception类，构造方法调用父类构造记录异常信息

public class MyException extends Exception{
     
     public MyException(String message){
          super(message);//调用父类构造函数
     }      
}

第五章：lang包下的包装类

　　8大基本类型：short、int、long、float、double、byte、char、boolean

　　对应的包装类：Short、Integer、Long、Float、Double、Byte、Character、Boolean这些包装类提供了对各个类型间进行转换和运算操作的方法

　　String为引用类型，且一旦定义之后不支持改变，如：

String a = "a";//创建了一个对象，变量a指向了对象"a"
a = a+"b";//重新创建了一个对象，变量指向了对象"ab"

String str = "a"+"b"+"c"；//只创建了一个对象

　　StringBuffer和StringBuilder是String的操作类，支持在同一个对象中改变其值；其中StringBuffer是线程安全的，效率较低；StringBuilder是线程不安全的，但效率高。

　　StringBuffer和StringBuilder还有一些对字符串进行操作的方法

StirngBuffer sb = new StringBuffer("a");
sb.append("b");//调用方法进行字符串拼接，此过程未创建第二个对象

第六章：util包下的集合Collection

　　1.Collection下的子接口有List、Set

　　　　List：有序可重复的序列，下面的常用子类：ArrayList、LinkedList、Vector

　　　　　　ArrayList：本质为Object[]

　　　　　　LinkedList：链式结构，首尾相连，插入和删除快速

　　　　　　Vector：与ArrayList相同，但是是线程安全的

　　　　Set：无序不重复，下面的常用子类有：HashSet、TreeSet

　　　　　　TreeSet可通过Comparable接口来指定排序规则（按什么进行排序）

　　2.Map:key-value(键值对的形式)，无序不重复的，因为其key是HashSet；缓存可以使用Map，如Redis就像一个大型的Map，缓存数据可以存在里面。下面的子类：HashMap、　　HashTable（线程安全）、TreeMap

　　　　Collections：集合的操作类，其方法可对集合进进排序、反转等

　　3.其他的工具类：Date（时间）、DateFormat、SimpleDateFormat（时间格式化类）、Properties（用于配置文件读取）、Calendar(日历)、UUID（生产不重复序列）等

第七章：IO（流）

　　输入输出流的理解：输入，是以自身程序为参考从硬盘或另一端程序输入到本程序（内存）。输出，是从本程序（内存）输出到硬盘或另一端程序。

　　字节流：

　　　　InputStream/OutputStream：接口

　　　　FileInputStream/FileOutputStream：类，普通字节流

　　　　ObjectInputStream/ObjectOutputStream：对象序列化流

　　　　ByteArrayInputStream/ByteArrayOutputStream：字节数组流

　　　　DataInputStream/DataOutputStream：数据字节流

　　字符流：

　　　　Reader/Writer：普通字符流

　　　　BufferedReader/BufferedWriter：带缓冲的字符流

　　　　InputStreamReader：字节转字符流，数据在传输过程中都是以字节的形式进行的，为了方便。所以有了这个转换字节为字符的类

　　　　OutputStreamWriter：字符转字节流，同样，字符对我们来说是容易操作的，但传输需要字节的形式，所以有了这个类。

第八章：线程

　　一个程序为一个进程，一个进程包含多个线程。

　　线程的理解：每创建一个线程，相当于创建了一条任务线，但是做任务的人只有一个（cpu），这个人三心二意，不可能同时去做所有事情，只能做一会儿这个，做一会儿那个，所以就有了线程安全的问题。如：很多人搬砖，每搬完一块砖需要到工头那记一次，但是当你跑去工头那让他记的时候，他说等一下，然后另一个人跑去让他记，把你的帐给忘了，导致你搬的砖数不对。

　　线程安全：每个任务线的数据都不能互相影响而导致另一个任务线的真实数据出错，每条任务线的数据都要保证是上一条任务线处理后的最新的最新的结果。

　　实现线程的3中方式：Thread的start()方法是将run()方法进行特殊处理，使其成为一个线程的方法，只有通过start()方法才能成为一个线程，直接调用run()只是一个普通方法

　　1.集成Thread类，重写run方法，调用start()方法开启线程，代码如下

/**
*自定义线程类
***/
public class MyThread extends Thread{
     
     public void run(){
          while(true){
              System.out.println("我是一个线程");
          }    
    }  
}    

//执行线程
public class MainTest{
     public static void main(Stirng[] args){
          MyThread mt = new MyThread();
          mt.start();//开启线程
     }
}

　　2.实现Runnable接口，重写run()方法，通过Thread包装后，调用start()方法开启线程

/**
*自定义线程类
**/
public class MyThread implements Runnable{
     
      public void run(){
            while(true){
                 System.out.println("我是一个线程");
            }
      }
}


//执行线程

public class MainTest{

      public static void main(String[] agrs){
              MyThread mt = new MyThread();
              Thread t = new Thread(mt);
              t.start();//开启线程
     }
}

　　3.实现Callable接口，重写call()方法，通过FutureTask类包装后调用run()方法开启线程，调用get()方法得到线程的返回值

/**
*自定义线程类
**/

public class MyCall implements Callable{

     public String call(){
          return "我是线程的返回值";
     }
}


/**
*测试线程
**/

public class MainTest{
      public static void main(String[] agrs){
            MyCall mc = new MyCall();
            FutureTask task = new FutureTask(mc);
            task.run();//开启线程
      }
}

第九章：网络编程（Socket、ServerSocket）

TCP方式：需要连接才能通信，浏览器与web服务器用的方式

　　1.创建服务端

/**
*创建服务器
**/
public class MyServer{
      public static void main(Stirng[] args){
            //创建服务器并给服务器开一个端口号，端口号代表了一个程序
            ServerSocket ss = new ServerSocket(18888);
            //接收连接
            while(true){
                   Socket s = ss.accept();//获取连接的Socket对象
                   s.getInputStream();//获取IO流进行数据传输
                   s.getOutputStream();//获取IO流进行数据传输
            }
      }
}

　　2.创建客户端

/**
*创建客户端
**/

public class MyClient{

          public static void main(String[] args){
                    Socket s = new Socket("127.0.0.1",18888); //连接服务器
                    s.getInputStream();//获取IO流进行通信
                    s.getOutputStream();//获取IO流进行通信   
          }
}

UDP：无连接通信　

　　1.服务端

/**
*服务器
**/
public class UDPServer{
    public static void main(String[] args)throws IOException{
        DatagramSocket  server = new DatagramSocket(5050);
        byte[] recvBuf = new byte[100];
        DatagramPacket recvPacket 
            = new DatagramPacket(recvBuf , recvBuf.length);//创建数据包
        server.receive(recvPacket);/接收数据包
        String recvStr = new String(recvPacket.getData() , 0 , recvPacket.getLength());
        System.out.println("Hello World!" + recvStr);
        int port = recvPacket.getPort();
        InetAddress addr = recvPacket.getAddress();
        String sendStr = "Hello ! I'm Server";
        byte[] sendBuf;
        sendBuf = sendStr.getBytes();
        DatagramPacket sendPacket 
            = new DatagramPacket(sendBuf , sendBuf.length , addr , port );
        server.send(sendPacket);//发送数据包
        server.close();
    }
}

　　2.客户端

/**
*客户端
**/

public class UDPClient{
    public static void main(String[] args)throws IOException{
        DatagramSocket client = new DatagramSocket();
        
        String sendStr = "Hello! I'm Client";
        byte[] sendBuf;
        sendBuf = sendStr.getBytes();
        InetAddress addr = InetAddress.getByName("127.0.0.1");
        int port = 5050;
        DatagramPacket sendPacket 
            = new DatagramPacket(sendBuf ,sendBuf.length , addr , port);
        client.send(sendPacket);//发送数据包
        byte[] recvBuf = new byte[100];
        DatagramPacket recvPacket
            = new DatagramPacket(recvBuf , recvBuf.length);
        client.receive(recvPacket);//接收数据包
        String recvStr = new String(recvPacket.getData() , 0 ,recvPacket.getLength());
        System.out.println("收到:" + recvStr);
        client.close();
    }
}

第十章：GUI

　　GUI由一些组件和事件组成一套系统，JFrame、JPannel等组件和给组件添加事件

JButton bt = new JButton();
bt.addMouseListener(new MouseListener() {
    public void mouseReleased(MouseEvent e) {
                
    }
            
    public void mousePressed(MouseEvent e) {
                
    }
            
    public void mouseExited(MouseEvent e) {
                
    }
            
    public void mouseEntered(MouseEvent e) {

    }
            
    public void mouseClicked(MouseEvent e) {
                
    }
});//匿名内部类，方便实现接口并创建实现类对象

内部类：类里面的类，与方法同级别

匿名内部类：为了方便实现接口创建实现类对象

静态内部类：静态内部类

JAVA学习网

分类