JAVA 新手入门

大家好，又见面了，我是你们的朋友全栈君。

前言

对于JDK的安装和环境配置，网上已经有很多资料，比如：这个是我随便搜的。
至于编辑器的话，我个人使用的是IDEA，因为刚好有教育邮箱，可以免费使用（这一点对于没有收入来源的学生来讲真的很赞）
另外，我是学习过C++的一名普通学生，所以之后的很多内容，我都会相较于C++来比较学习，这样也便于快速理解，或许对于没有C++或类似基础的同胞们不太友好，请谅解。
以下都只是精简地概述，若想更详细地了解，可以去各大网站搜索javaSE教程，会详细地多。

基础语法

进入正题，对于任何一门语言，相信绕不过的第一个程序，自然就是Hello world!
相较于C++中，一个简单粗暴的main函数，你刚开始或许会觉得这个写在类里面的main函数很奇怪，但这其实并无伤大雅。不过这里要注意的一点，main函数里的参数：String[] args 是一定要写的。
如果你是用IDEA编写的话，你可以直接键入psvm就能直接打出main函数了。
同理，对于System.out.println()也可以通过键入sout来快速输入。
其实对于java中的基础语法来讲，很多都是和C++类似。比如：

1. 循环结构中的while,for,do while是基本一致的
2. 选择结构中的if,else,else if等也是基本一致的
3. 基本数据类型的变量定义（这里不完全一样）
   1.java中数字的默认类型为int型，小数为double型，想要转化为长整型long的数字要在末尾添加L，想转化成float型的数字要在末尾添加F。
   2.字符串类型为String，布尔类型在java中是boolean。
   3.数组的定义一般是直接new出来的，储存在堆内存中。
4. java中的控制台输出和C++相差无几，同时java中也支持System.out.printf()，键盘输入与C++有出入，后边再提。

如果是一名有C++基础的java初学者，到这里，其实就可以去写一些简单的算法题了。不是很熟悉的伙计们，可以先去写几道算法题熟悉下。

Java的语言特性

面向对象的思想

如同C++一般，java也具有面向对象的三大特性：封装性，继承性，多态性。
tip:java只能单继承，一个子类只能有一个父类，一个父类可以有多个子类
其实之前提到的字符串类型String也是一个类，因此在创建字符串的过程中也可以使用String str=new String("Hello world!")（这样看是不是通俗多了），在Java的学习过程中，会发现很多利用类与对象进行操作的时候。
再举个例子：java中的键盘输入，也是需要创建对象的。

Scanner scan=new Scanner(System.in);	//这里先是创建一个Scanner对象
scan.next()								//从键盘输入，返回一个字符串
scan.nextInt()							//从键盘输入，返回一个int型的数据
										//同理，还有各种类型，可以通过IDEA的提示，来一一查询

接口

与我们之前创建的Java类文件不同，在创建一个新的java类文件的时候，选择Interface（也就是接口）

接口也可以形象地理解为抽象类，里边包含各种需要重写的抽象方法，当然也可以包含私有方法，默认方法等。
同时，相较于单继承，一个类可以有多个接口，但是除非这个类也是抽象类，不然就必须重写所有的抽象方法。

泛型

java中的泛型也可以理解为C++中的模板类。
自定义类中的泛型案例：

这是接口中的泛型案例：

对于接口中的泛型案例，有两种方法：

1. 直接在实现类中定义泛型的类型：
   
   2.在实现类里不定义泛型的类型，在创建实现类对象时再定义泛型类型：
   
   再在main函数中定义：Generic_InterfaceImpl2<Integer> i2=new Generic_InterfaceImpl2<Integer>();

File IO流

File IO流这里简要介绍下字节流和字符流。
首先我们要明确一个概念，计算机中所有的文件，都可以通过字节传递。也就是说我们自然可以通过字节来复制文件。
下面放个复制文件的例子：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class IO_copy_File { 
   
//别忘了要在main函数出添加抛出IOExcpetion异常
    public static void main(String[] args)throws IOException
    { 
   
        long start=System.currentTimeMillis();													//这个用来记录当前的毫秒值
        FileInputStream fip=new FileInputStream("C:\\Users\\zzz\\Desktop\\活动2.jpg");			//这里定义了文件输入流的路径
        FileOutputStream fop=new FileOutputStream("D:\\test.jpg");			//定义了文件输出流的路径
        byte[] b=new byte[1024];											//通过字节数组来传递
        int len;
        while((len=fip.read(b))!=-1)										//fip.read(b)是一次性往b数组内读入有效字节，具体多少个字节由len来计数，若无了，则len为-1，也就是已经复制完毕
        { 
   
            fop.write(b,0,len);												//同理，这里就是往目标位置写入
        }
        fip.close();														//复制完毕后要记得关闭流，以节约资源
        fop.close();
        long end=System.currentTimeMillis();
        System.out.println("复制文件共耗时："+(end-start)+"秒");
    }
}

但是如果是要对字符进行操作，比如我想把文件内容打印输出到控制台，或者将一个文档的内容输出到另一个文档，这里我们用到字符流则会方便很多。
比如这个例子（实现将一个txt文档的内容输入到另一个txt文档）：

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class IO_File_Write_Read { 
   
    public static void main(String[] args)throws IOException
    { 
   
        FileReader fr=new FileReader("C:\\Users\\zzz\\Desktop\\1.txt");
        FileWriter fw=new FileWriter("d:\\2.txt");
        char[] a=new char[1024];
        int len;
        while((len=fr.read(a))!=-1)
        { 
   
            fw.write(a,0,len);
            System.out.println(new String(a,0,len));
        }
        fr.close();
        fw.close();
    }
}

多线程编程

程序：静态的代码
进程：动态执行的程序
线程：进程中要同时干几件事时，每一件事的执行路径称为线程
我们电脑运行过程中的每个进程往往会有一个甚至多个线程，比如浏览器中可以同时打开多个网页，每个网页上各自运行着不同的任务。
那么java中的多线程编程也可以粗略地理解为同时进行多个不同的任务。举个简单的例子：

public class Main { 
   
    public static void main(String[] args) { 
   
        Thread_son1 t1=new Thread_son1();
        t1.start();							//注意：开启线程是start()方法
        for (int i = 0; i < 50; i++) { 
   
            System.out.println("main:"+i);
        }
    }
}

public class Thread_son1 extends Thread{ 
   
    public Thread_son1(){ 
   }
    public Thread_son1(String name){ 
   
        super(name);
    }
    @Override
    public void run(){ 
   
        for(int i=0;i<50;i++){ 
   
            System.out.println("Thread_son1:"+i);
        }
    }
}

我们创建了一个类来继承Thread类后，重写run()方法，也就是Thread_son1这个类的线程任务。再在main函数中，写了一个类似的for循环。
那么这样其实是两个线程的并行。
一个是我们创建的对象t1，另一个就是main函数。
那么此时t1和main之间就会调用CPU资源，当然这种情况我们的CPU就是随机选择一个执行。那也就是说我们每次运行这个主函数，打印输出的结果不一定一致。

以上只是实现多线程的一种方法，通过自定义类来继承Thread类，但是如果我们此时要继承别的类怎么办？
这种时候java给我们提供了一种别的方式，利用Runnable接口来实现同样的效果。
这个拿一个比较现实的例子来理解：

public class Main_maipiao { 
   
    public static void main(String[] args) { 
   
        piao m1=new piao();
        Thread one=new Thread(m1);
        Thread two=new Thread(m1);
        Thread three=new Thread(m1);
        one.setName("窗口一");
        two.setName("窗口二");
        three.setName("窗口三");
        one.start();
        two.start();
        three.start();
    }
}

public class piao implements Runnable{ 
   
    private  int count=100;
    @Override
    public void run() { 
   
        while (true){ 
   
            synchronized (this){ 
   
                if(count<=0) break;
                System.out.println(Thread.currentThread().getName()+"正在出售第"+count+"张票");
                count--;
            }
            try { 
   
                Thread.sleep(1000);
            } catch (InterruptedException e) { 
   
                e.printStackTrace();
            }
        }
    }
}

这是一个很典型的例子，三个窗口出售100张票，我们的自定义piao类使用了Runnable接口，再用这个piao类创建的对象作为参数传给Thread类的构造函数。
但是我们面对这样一个问题不得不注意：我们的线程是并行的，也就是说我们会出现不同的两个窗口同时卖出了同一张票的尴尬情况。
那么如何解决这个问题呢？
这里就可以用到同步锁synchronized。
synchronized中需要传递一个object类参数，为了图方便，就拿this代替了。可以理解为公共厕所门锁上有无人的标识。
当一个线程正在执行m1中的同步代码块时，就会先检查这个标识，如果发现已经有线程在执行，那么该线程就会处于阻塞状态。一旦执行这个同步代码块的线程执行完代码块时，就会自动将这个标识变为 “无人”，此时所有的线程就可以再次调用CPU资源来执行这个代码块，以保证同一时间只有一个线程在执行该代码块。
同理，Thread.sleep()(其中的参数单位为毫秒) 也会让当前的线程处于阻塞状态，直到超时，那么这样就可以把这个代码块 “让给” 别的线程。
这样来解决线程安全问题。