JAVA开发准备

Java基础语法：包括变量、数据类型、运算符、控制流、异常处理、面向对象编程（封装、继承、多态）等基本概念。

1.变量

内存中的一个存储区域

该区域的数据可以在同一类型范围内不断变化

变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值，用于在内存中储存数据

2.数据类型

3.控制流

4.异常处理

指的是程序在执行过程中，出现非正常的情况，最终导致JVM出现非正常停止。

在Java等面向对象的编程语言中，异常本身就是一个类，产生异常就是创建异常对象，并抛出了一个异常对象，Java处理异常的方式是中断处理。

ava异常处理的五个关键字：try、catch、finally、throw、throws。

Java语言中的异常处理包括声明异常、抛出异常、捕获异常和处理异常四个环节。

throw用于抛出异常。

throws关键字可以在方法上声明该方法要抛出的异常，然后在方法内部通过throw抛出异常对象。

try是用于检测被包住的语句块是否出现异常，如果有异常，则抛出异常，并执行catch语句。

cacth用于捕获从try中抛出的异常并作出处理。

finally语句块是不管有没有出现异常都要执行的内容。

5.面向对象编程（oop）

面向对象编程三大特性------封装、继承、多态-CSDN博客

封装

一个对象它所封装的是自己的属性和方法，所以它是不需要依赖其他对象就可以完成自己的操作。使用封装有四大好处：

1、良好的封装能够减少耦合。

2、类内部的结构可以自由修改。

3、可以对成员进行更精确的控制。

4、隐藏信息，实现细节。

继承

构造器、protected关键字、向上转型

继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。

1、父类变，子类就必须变。

2、继承破坏了封装，对于父类而言，它的实现细节对与子类来说都是透明的。

3、继承是一种强耦合关系。

多态

子类Child继承父类Father，我们可以编写一个指向子类的父类类型引用，该引用既可以处理父类Father对象，也可以处理子类Child对象，当相同的消息发送给子类或者父类对象时，该对象就会根据自己所属的引用而执行不同的行为

ava实现多态有三个必要条件：继承、重写、向上转型。

    继承：在多态中必须存在有继承关系的子类和父类。

    重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。

    向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。

    只有满足了上述三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。

JAVA集合框架

1. ArrayList（有序）

用法：ArrayList是一个可变大小的数组实现，适用于需要频繁访问元素的场景。

public class MyArrayList {

    //整个集合最关键的部分，定义数组保护数据

    private Object[] elementData;



    //数组会有长度，保存几个数据，长度就为几

    private int size;



    /**

    *通过构造方法，办初始化事件

    * 当集合被创建时候，定义一个默认长度

    */

    public MyArrayList(){

       elementData = new Object[10];

    }



    public void add(Object obj){

        //关键问题，数组长度本身不可变，所以我们把数组长度定为10之后



        if (size >= elementData.length) {

            //数组容量不够定义新数组,长度翻倍

            Object[] temp = new Object[elementData.length * 2];

            //数组的复制，我们不能丢掉原先的elementData的数据,而是把它复制到temp里面去

            System.arraycopy(elementData,0,temp,0,size);

        }

        //先复制再自增

        elementData[size++] = obj;

    }



}

2. LinkedList

用法：LinkedList是一个双向链表实现，适用于需要频繁插入和删除元素的场景。

public class MyLinkList {



    private Node first;



    private Node last;



    private int size;



    public void add(Object obj){

        Node node = new Node();

        if(first==null){

            //当第一个节点不存在，集合为空

            node.prev = null;

            node.next = null;

            node.setObj(obj);

            first = node;

            last  = node;

        }else {

            //当第一个节点存在之后，就都好处理了，直接往后面关联就行了

            node.prev = last;

            node.next = null;

            node.setObj(obj);

            last.next = node;

            last = node;

            //最后，当我们把原先的最后一个节点都设置好后，就可以放心把新节点

            //覆盖到last节点

        }

    }



}



public class Node {



    //最核心的变量，这个变量用来保存当前节点的数据

    public Object obj;



    //保存前一个节点

    public Node prev;



    //保存最后一个数据

    public Node next;



    public void setObj(Object obj){

        this.obj = obj;

    }



    /**

     *带参数的构造方法，便于做节点

     */



    public Node(Object obj, Node prev, Node next) {

        super();

        this.obj = obj;

        this.prev = prev;

        this.next = next;

    }



    /**

     *不带参数的构造方法

     */

    public Node() {



    }

}

3. Vector

用法：Vector与ArrayList相似，但是线程安全，适用于并发环境。

实例：

Vector<String> vector = new Vector<>();

vector.addElement("orange");

String element = vector.elementAt(0);

vector.removeElement("orange");

Enumeration<String> enumeration = vector.elements();

while (enumeration.hasMoreElements()) { ... }

三、Set集合

1. HashSet（无序）

用法：HashSet使用哈希表实现，适用于不允许重复元素的场景。

实例：

HashSet<String> set = new HashSet<>();

set.add("cat");

boolean exists = set.contains("cat");

set.remove("cat");

for (String element : set) { ... }

2. TreeSet

用法：TreeSet使用红黑树实现，适用于需要元素自动排序的场景。

实例：

TreeSet<String> set = new TreeSet<>();

set.add("dog");

String firstElement = set.first();

set.remove("dog");

Iterator<String> iterator = set.iterator();

while (iterator.hasNext()) { ... }

四、Map集合

HashMap（键值对）

用法：HashMap是基于哈希表的键值对实现，适用于需要快速查找和存储键值对的场景。

实例：

HashMap<String, Integer> map = new HashMap<>();

map.put("apple", 10);

Integer value = map.get("apple");

map.remove("apple");

for (Map.Entry<String, Integer> entry : map.entrySet()) { ... }

JUnit单元测试

1.确保单个方法运行正确

2.如果修改了方法代码，只需确保其对应的单元测试通过

3.测试代码本身就可以作为示例代码

4.可以自动化运行所有测试并获得报告

步骤：定义一个测试类（测试用例）

测试类名：被测试的类名Test 比如：CalculatorTest

包名：xxx.xxx.xx.test cn.itcast.test

定义测试方法：可以独立运行

方法名：test测试的方法名 testAdd()

返回值：void

参数列表：空参

给方法加@test

导入Junit的依赖环境

判定结果：

红色：代表失败

绿色：代表成功

使用示范：

1.选中类名，按快捷键Ctrl+Shift+t，选择Create new Test，用于自动生成测试类

2.如果创建的自定义测试类即使添加路径后仍然报错解决方案如下

IO流（Java输入输出）

File常用方法分类

1.创建、删除、重命名文件

创建文件

 //创建File对象

 File file = new File("/D:/WePush/neigei.txt");

 //当文件不存在时

 if(!file.exists()){

  //创建新文件

 try {

     //创建新文件

     boolean result = file.createNewFile();

        System.out.println(result);

     } catch (IOException e) {

        e.printStackTrace();

        }

     }

     

重命名文件

//创建File对象

File file = new File("/D:/WePush/neigei.txt");

//当文件存在时

if(file.exists()){

    //重命名文件

    boolean result = file.renameTo(newFile("/D:/WePush/geinei.txt"));

    System.out.println(result);

}

删除文件

 //创建File对象

        File file = new File("/D:/WePush/geinei.txt");

        //当文件存在时

        if(file.exists()){

            //删除文件

            boolean result = file.delete();

            System.out.println(result);

        }

创建目录

//创建目录

File file = new File("/D:/WePush/nige");

// 当目录不存在时

if (!file.exists()){

   // 创建目录

   boolean result = file.mkdir();

   // 输出创建结果

    System.out.println(result);

重命名目录

//创建目录

File file = new File("/D:/WePush/nige");

// 当目录存在时

if (file.exists()){

   //重命名目录

    boolean result = file.renameTo(new File("/D:/WePush/尼格"));

    //输出重命名结果

    System.out.println(result);

}

删除目录

//创建File对象

File file = new File("/D:/WePush/neigei");

//当目录存在时

if(file.exists()){

    //重命名文件

    boolean result = file.delete();

    System.out.println(result);

}

递归删除

public static void main(String[] args) {

        //创建目录

        File file = new File("/D:/WePush/nige");

        //递归删除

        boolean result = recursionDelete(file);

        System.out.println(result);

    }

    public static boolean recursionDelete(File file){

        //当为目录时

        if(file.isDirectory() && file.exists()) {

            //列出以下所有文件

            File[] files = file.listFiles();

            //当数组不为空时

            if(files != null){

                //遍历数组

                for(File f: files){

                    //删除递归文件

                    recursionDelete(f);

                }

            }

        }

        //删除文件

        return file.delete();

}

创建多级文件

//创建目录

        File file = new File("/D:/WePush/neigei/内给/耿王睿智");

        // 当目录不存在时

        if (!file.exists()){

            // 创建多目录

            boolean result = file.mkdirs();

            // 输出创建结果

            System.out.println(result);

        }

字符的存储

字符对应ASCII码找到对应码值，将码值转为字节存储

字节输入流InputStream

try {

   //创建文件字节输入流

   FileInputStream in = new FileInputStream("/D:/WePush/neigei.txt");

   //字节值

   int b;

   //循环读取

   while ((b = in.read()) != -1){

         System.out.println((char)b);

         }

    } catch (FileNotFoundException e) {

        e.printStackTrace();

    } catch (IOException e) {

        e.printStackTrace();

} finally{

    if(in != null){

     //关闭流

      try {

             in.close();

          } catch (IOException e) {

              e.printStackTrace();

              }

         }

  }

关闭流

In.close(); 不关闭会导致文件无法使用

  输出流（OutputStream）

复制

1.声明输入并初始化输出流

2.边读边写

3.关闭输入输出流