Java编程入门核心要点

0.基本与结构

1. 程序组成

2. 入门程序

package com.hao;
class adder{   //外部类，具有包访问性
    int a,b;//成员变量
    int add(int a,int b){  //类的方法
        return a+b;
    }
}
public class Main {  //public修饰主类，具有唯一性，是程序运行入口，外部类为其服务
    public static void main(String[] args) {
        adder a = new adder();//创建类的对象
        int result = a.add(1,1);//调用对象的方法
        System.out.println(result);//输出方法的返回数据
    }
}

1.类

1. 类是一个运行基本单位，一个运行单元可有多个类，但一般必有一个主类，其他类被主类调用
2. 主类是包含public static void main(String[] args)函数的类，main()是程序运行的入口
3. public类的类名必须和文件名一致，以方便调用
4. 类在使用前需要使用new运算符初始化为一个实例即对象
5. 接口实质是一种特殊的抽象类
6. 修饰符 类名{成员变量;方法}
7. 对象的创建包括初始化和实例化两个过程

2.方法

1. 在接口中声明方法，在类中实现或调用方法
2. 修饰符 返回值数据类型 方法名(参数列表){方法体}
3. 类的构造方法的作用是为了初始化类的成员变量或者其他初始化工作
4. 方法重载：方法名，返回值数据类型相同，参数列表不同

3.特殊关键字

1. 修饰

2. 引用

1.implements 可引用多个接口，用逗号分隔
2.extends 只能继承一个父类

4.基本数据类型与其包装类

1.基本数据类型

​ 整型：byte(1B), short(2B), int(4B), long(8B)
​ 字符型：char(2B)
​ 浮点型：float(4B), double(8B)
​ 布尔型：boolean(默认false)

2.包装类

1.What? 八种基本数据类型对应的类统称为包装类
2.Why？ Java是面向对象的编程语言，但八种基本数据类型却是不面向对象的
3.How？除Integer和Character类，其它六个类只是类名的第一个字母大写即可。
4.Work?
     方便涉及到对象的操作
     包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法

3.基本数据与包装类间的转换

Integer i=new Integer(50);
int i1 = i.intValue();

4.自动拆装箱
JDK自从1.5版本以后，就引入了自动拆装箱的语法，也就是在进行基本数据类型和对应的包装类转换时，系统将自动进行。
5.Integer类内部的常用方法

1.parseInt方法： 数字字符串类型转成int类型
2.toString方法：int类型转成数字字符串类型

5.声明与初始化

1.变量必须先声明再使用
2.成员变量有默认值，可以不进行初始化；而所有局部变量则必须进行显式初始化
3.基本类型初始化默认值为0，boolean为false，字符串或者对象引用初始化为null。

6.数组

1.声明的同时为数组分配内存

int month[] = new int[12];//一维数组
int date[][] = new int[12][31];//二维数组
//分别为每一维分配内存
arr = new int[2][];     
arr[0] = new int[3];
arr[1] = new int[5];
//整型数组中各个元素初始值都是0

2.初始化

//一维数组
int arr1[] = new int[]{1,2,3,4,5}; 
int arr2[] = {1,2,3,4};  
//二维数组
int myarr[][] = {{1,2,3},{3,4,5,6}};   //为每一维分配内存的数组

3.从数组创建一个 ArrayList

String[] stringArray = { "a", "b", "c", "d", "e" };
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));
System.out.println(arrayList);
// [a, b, c, d, e]

4.打印数组

int[] intArray = { 1, 2, 3, 4, 5 };
String intArrayString = Arrays.toString(intArray);
// 直接打印会输出引用值
System.out.println(intArray);
// [I@1540e19d
System.out.println(intArrayString);
// [1, 2, 3, 4, 5]

5.检查数组是否包含某一个值

String[] stringArray = { "a", "b", "c", "d", "e" };
boolean b = Arrays.asList(stringArray).contains("a");
System.out.println(b);
// true

6.合并数组

int[] intArray = { 1, 2, 3, 4, 5 };
int[] intArray2 = { 6, 7, 8, 9, 10 };
// Apache Commons Lang library
int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2);

7.一行代码声明数组

method(new String[]{"a", "b", "c", "d", "e"});

8.把数组中的元素用指定的分隔符连接起来

// containing the provided list of elements
// Apache common lang
String j = StringUtils.join(new String[] { "a", "b", "c" }, ", ");
System.out.println(j);
// a, b, c

9.把一个 ArrayList 转换成数组

String[] stringArray = { "a", "b", "c", "d", "e" };
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));
String[] stringArr = new String[arrayList.size()];
arrayList.toArray(stringArr);
for (String s : stringArr)
	System.out.println(s);

10.把一个数组转换成 Set

Set<String> set = new HashSet<String>(Arrays.asList(stringArray));
System.out.println(set);
//[d, e, b, c, a]

11.反转数组

int[] intArray = { 1, 2, 3, 4, 5 };
ArrayUtils.reverse(intArray);
System.out.println(Arrays.toString(intArray));
//[5, 4, 3, 2, 1]

12.移除数组中的元素

int[] intArray = { 1, 2, 3, 4, 5 };
int[] removed = ArrayUtils.removeElement(intArray, 3);//create a new array
System.out.println(Arrays.toString(removed));

13.把 int 转换成字节数组

byte[] bytes = ByteBuffer.allocate(4).putInt(8).array();
for (byte t : bytes) {
   System.out.format("0x%x ", t);
}

7.I/O流

1.控制台I/O

Scanner scanner = new Scanner(System.in);
int a = scanner.nextInt();//输入a
System.out.println(a);//输出a

2.文件I/O
File类

File f1=new File("src\\test.txt");//相对路径，如果没有前面的src，就在当前目录创建文件
		if(f1.exists()) {
			System.out.println("文件已经存在");
		}else {
			try {
				f1.createNewFile();
				System.out.println("文件创建成功");
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		System.out.println("文件的名字:"+f1.getName());
		System.out.println("文件的路径:"+f1.getPath());
		System.out.println("文件的绝对路径:"+f1.getAbsolutePath());
		System.out.println("是目录吗:"+f1.isDirectory());
		System.out.println("文件大小:"+f1.length());

3.字节流
1.InputStream接口和OutputStrem接口
2.文件的字节流操作类是实现1中两个接口的FileInputStream类和FileOutputStrem类
2.操作单位为一个字节，对于仅含数字或字符的文本文件也可以操作，输出时可以保证不出现乱码
3.read每调用一次就会读取文本内容的下一个字节，读取方式为一个个的读取，效率低
4.以byte数组方式读取，效率高

byte[] bytes = new byte[1024];  //1kb
File file = new File("F:/a.txt");
FileInputStream fileInputStream = new FileInputStream(file);
//以一个kb的方式去读取，如果文本内容不超过一个kb的话就会全部读取，将读取到的内容放在byte数组中并且返回文本内容的字节数
int read = fileInputStream.read(bytes);
String s = new String(bytes);
System.out.println(s);

5.写入文本

FileOutputStream fileOutputStream=newFileOutputStream("F:/b.txt");
//FileOutputStream fileOutputStream=new FileOutputStream("F:/b.txt",true);默认为false,会覆盖文件原有内容，而true是以追加的形式将字节写入文件
fileOutputStream.write(bytes);//bytes就是我们之前使用输入流从a.txt中拿到的文本内容

4.字符流
1.操作单位为一个字符(多个字节)，用于操作含中文字符的文本文件
2.两个标准接口：Reader接口和Write接口
3.Reader接口的三个重要实现类

• InputStremReader类

File file = new File("F:/a.txt");
FileInputStream fileInputStream = new FileInputStream(file); //获取字符输入流
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"gbk");//传入文件字符流和字符编解码方式
char[] c = new char[64];
int read = inputStreamReader.read(c);
System.out.println( new String(c));

• FileReader

File file = new File("F:/a.txt");
FileReader fileReader = new FileReader(file );
char[] c = new char[64];
int read = inputStreamReader.read(c);
System.out.println( new String(c));

• BufferedReader

File file = new File("F:/a.txt");
//获取文件的字节输入流
FileInputStream fileInputStream = new FileInputStream(file);
//获取字符输入流
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
String line = null;
while ((line=bufferedReader.readLine())!= null){
System.out.println(line);
}
//BufferedReader需要接收一个字符流 InputStreamReader，然后就可以直接调取readLine方法进行整行读取，会得到一个字符串，可以直接输出，因为是整行读取可以保持格式不乱

4.Writer接口的重要实现类

//将a.txt内容写入b.txt
File file = new File("F:/a.txt");
File file1 = new File("F:/b.txt");
//获取文件的字节输入流
FileInputStream fileInputStream = new FileInputStream(file);
//利用字节输入流获取字符输入流
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);//BufferedReader的获取需要InputStreamReader流作为参数输入
//获取字符输出流
FileOutputStream fileOutputStream = new FileOutputStream(file1);
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream);
BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter);
//按行写入
String line = null;
while ((line=bufferedReader.readLine())!= null){
        System.out.println(line);
        bufferedWriter.write(line);
        bufferedWriter.newLine();
 }
//一个流如果没有关闭，则处于被占用状态，那么一些操作我们是完成不了的,利用try代码块关闭

5.序列化
1.什么是序列化和反序列化？
序列化：将java对象转化为字节序列的过程。
反序列化：将字节序列转化为java对象的过程。

2.为什么要将对象序列化？
Java进程间进行通信时，实现进程间的对象传送

3.如何进行序列化和反序列化？
一方面，发送方需要把这个Java对象转换为字节序列，然后在网络上传送；另一方面，接收方需要从字节序列中恢复出Java对象。

4.序列化的作用是什么？
一是实现了数据的持久化，通过序列化可以把数据永久地保存到硬盘上（通常存放在文件里）
二是利用序列化实现远程通信，即在网络上传送对象的字节序列。

5.序列化和反序列化的具体步骤是什么？

	序列化：
	
     步骤一：创建一个对象输出流，它可以包装一个其它类型的目标输出流，如文件输出流：

                      ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(“目标地址路径”));

     步骤二：通过对象输出流的writeObject()方法写对象：

                      out.writeObject("Hello");

                      out.writeObject(new Date());

     反序列化：        

      步骤一：创建一个对象输入流，它可以包装一个其它类型输入流，如文件输入流：

                      ObjectInputStream in = new ObjectInputStream(new fileInputStream(“目标地址路径”));

     步骤二：通过对象输出流的readObject()方法读取对象：

                    String obj1 = (String)in.readObject();

                    Date obj2 =  (Date)in.readObject();

说明：为了正确读取数据，完成反序列化，必须保证向对象输出流写对象的顺序与从对象输入流中读对象的顺序一致。

6.编程举例说明序列化和反序列化？
1.在要进行序列化的Person类后引用Serializable接口
2.序列化Person对象，将其存储到 E:/hello.txt文件中

 private static void SerializePerson() {  
        Person person =new Person();  
        person.setAge(30);  
        person.setName("SerializePerson");  
        ObjectOutputStream outputStream = null;  
        try {  
            outputStream=new ObjectOutputStream(new FileOutputStream("E:/hello.txt"));  
            outputStream.writeObject(person);  
            System.out.println("序列化成功。");  
        } catch (FileNotFoundException e) {  
            e.printStackTrace();              
        } catch (IOException e) {  
            e.printStackTrace();          
        } finally {  
            try {  
                outputStream.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }         
    }  

3.反序列化hello.txt中字节成Person对象，并返回Person对象。

private static Person DeserializePerson() {          
        Person person=null;  
        ObjectInputStream inputStream=null;  
        try {  
            inputStream=new ObjectInputStream(new FileInputStream("E:/hello.txt"));  
            try {  
                person=(Person)inputStream.readObject();  
                System.out.println("执行反序列化过程成功。");  
            } catch (ClassNotFoundException e) {  
                e.printStackTrace();  
            }  
        } catch (FileNotFoundException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        } finally {  
            try {  
                inputStream.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
        return person;  
    }  

7.序列化ID的作用是什么？
在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地实体类中的serialVersionUID进行比较，如果相同则认为是一致的，便可以进行反序列化，否则就会报序列化版本不一致的异常。

8.循环结构

1.for

for（初始化;条件表达式;更新）{
      //循环体
}
//适合循环次数已知的循环
//初始化语句仅开始执行一次以后按以下顺序循环,条件表达式->循环体->更新语句

2.do-while

do{
//循环体
}while(循环条件);
//适合循环次数未知，且即使不符合循环条件也会执行一次

3.while

while（循环条件）{
//循环体
}
//适合循环次数未知，符合条件才会执行循环体

9.分支结构

1.if语句结构

if(表达式){
条件成立将执行的逻辑代码;
}

2.if…else语句

if…else的语句结构：
if(表达式){
	符合if条件的代码块
}else{
	else的代码块
//表示不符合if条件的其他任何条件 都执行这里的代码块
//else不能单独使用，必须结合if使用
}

3.else if语句

if(①){
代码块①
}else if(②){
代码块②
}else if(③){
代码块③
}
/**
如果符合①，执行代码块①，如果不符合①，符合②，则执行代码块②，
如果不符合①和②，符合③，则执行代码块③
**/

4.switch语句

switch(常量表达式){
case(常量1) : 代码1
case(常量2) : 代码2
case(常量3) : 代码3;break;
default :代码3;break;
}
//不加break会将前面所有代码全部执行

10.常用类

1.Math类

abs(int a):绝对值
ceil(double d):向上取整
floor(double d):向下取整
max(int a,int b):最大值
pow(double a,double b):a的b次幂
random():随机数[0.0,1.0）
round(float f):四舍五入
sqrt(double d):算术平方根

2.Random类

1.构造方法
Random():以当前时间毫秒值作为种子，创建Random对象
Random(long seed):以指定种子创建Random对象
2.成员方法
nextInt():生成1个int类型范围的随机数
nextInt(int n):产生1个[0,n-1]范围内的随机数
3.生成0~n之间的数
①(int)Math.random()*(n+1)
②Random r  = new Random();
r.nextInt(m)表示生成[0,m-1]之间的随机数，也就是说random.nextInt(m+1)，将生成[0,m]之间的随机整数。
r.nextInt(n+1)
生成n~m之间的随机数
①n+(int)(Math.random()*(m+1-n));
②Random r = new Random();
r.nextInt(m+1-n)+n;

3.Date类

表示特定的瞬间，精确到毫秒值
1）构造方法
Date():以当前时间毫秒值创建Date对象
Date(long time):以指定的毫秒值创建Date对象
2）成员方法
long getTime():获取Date对象的毫秒值
setTime(long time):设置Data对象的毫秒值

4.DateFormat

它是一个抽象类，用来格式化或者解析日期
格式化：Date————》String
解析：String————》Date
getDateInstance(int style,Locale loc):获取日期格式器，该格式器具有给定的语言环境和给定的格式化风格
String format(Date date):格式化
Date parse(String time):解析

5.SimpleDateFormat

它是DateFormat的子类
1）构造方法
SimpleDateFormat():以默认模式创建对象
SimpleDateFormat(String pattern):以指定模式创建对象

常用模式
yyyy:年     MM:月    dd:日
HH:时    mm:分    ss:秒

2）常成员方法
String format(Date date):格式化
Date parse(String time):解析

6.Calendar类

日历类，用于获取或者操作日历字段（年月日）
该类是一个抽象类，不可以实例化
成员方法
static Calender getInstance():以默认时区和语言创建日历
int get(int field):获取指定字段的日历值
set(int field,int value):给指定的日历字段设置指定的值
set(int year,int month,int date):设置年月日
Date getTime():获取日历对象的日期
setTime(Date d):设置日历对象的日期
add(int field,int amount):对指定的日历字段添加指定的值

7.System类

没有构造方法
成员方法
gc():运行垃圾回收处理机制（系统会在某个不确定的时间调用该方法）
会调用finalize()，进行垃圾回收

exit(int status):退出JVM，0表示非异常退出
currentTimeMills():获取当前时间毫秒值
arrayCopy(Object[] srcArr,int srcPos,Object[] desArr,int destPos,int len):数组复制

8.BigInteger类

1）构造方法
BigInteger(String s):通过字符串创建BigInteger对象
2）成员方法
add(BigInteger bi):+
subtract(BigInteger bi):-
multiply(BigInteger bi):*
divide(BigInteger bi):/

9.BigDecimal类

用于解决浮点型运算精度损失的问题
1）构造方法
BigDecimal(String s):通过字符创建BigDecimal对象
2）成员方法
add(BigDecimal bi):+
subtract(BigDecimal bi):-
multiply(BigDecimal bi):*
divide(BigDecimal bi):/

10.Scanner

1.构造方法
      Scanner(InputStream is)
      构造一个文本扫描器，它生成的值是从指定的值输入流扫描的
      System.in 是一个标准的输入流，属于InputStream
2.成员方法
      boolean hasNext():是否有下一个数,有true，没有false
      String next():获取下个数
      int nextInt():获取下个int数据
      String nextLine():获取一行数据

11.Object

所有类的默认父类
1. clone()
保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。
2. getClass()
final方法，返回Class类型的对象，反射来获取对象。
3. toString()
该方法用得比较多，一般子类都有覆盖，来获取对象的信息。
4. finalize()
该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。
5. equals()
比较对象的内容是否相等
6. hashCode()
该方法用于哈希查找，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。
7. wait()
wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。
调用该方法后当前线程进入睡眠状态，直到以下事件发生。
其他线程调用了该对象的notify方法。
其他线程调用了该对象的notifyAll方法。
其他线程调用了interrupt中断该线程。
时间间隔到了。
此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。
8. notify()
该方法唤醒在该对象上等待的某个线程。
9. notifyAll()
该方法唤醒在该对象上等待的所有线程

12.String

1.构造

String str = new String("I am a string."); //立即在堆上创建一个String对象，然后将该对象的引用返回给用户。 
String str = "I am a string"  //jvm首先会在String Pool判断是否存在该String对象。如果有，则返回已有的String对象，如果没有，则在heap中重新创建对象，将其引用返回给用户同时将该引用添加至String Pool中。

//堆内存用于存放由new创建的对象和数组
//函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。

2.常用方法
	1.length()
		length求一个字符串的长度
	2.charAt()
		char charAt(int index)，返回String中index下标位置处的char，若index不合法，抛出IndexOutOfBoundsException异常。
	3.getBytes()
		用平台默认的编码方式对String进行编码，并将结果储存到一个新的byte数组中。
	4.toCharArray()	
		将String转换成一个char数组
	5.equals()	
		public boolean equals(Object anObject)比较源String和anObject内容是否相等，
	6.equalsIgnoreCase()
		用法类似equals()，只不过比较时忽略大小写
	7.compareTo()
		public int compareTo(String anotherString)，按字典顺序比较两个String的大小。
	8.contains()
		boolean contains(CharSequence s)，判断源String中是否含有s。包含则返回1，不包含则返回0。	
	9.indexOf()
		int indexOf(int ch)，从左往右查找ASCII码为ch的字符，如果存在则返回该字符的下标。如果不存在，则返回-1		
	10.substring()
		String substring(int beginIndex, int endIndex)，返回String下标从beginIndex到下标endIndex-1之间的字符串。
	11.concat()
		拼接两个字符串
	12.replace()
		String replace(char oldChar, char newChar)，从这个函数原型中就可以看出就是将String中的oldChar替换成newChar啦。
	13.toUpperCase()和toLowerCase()	
		转成大写/小写。
	14.valueOf()
		返回一个表示参数内容的String，参数可以是double，int，float，char，char[]，long等之类的，基本都可以。实际上就是类型转换，把其它类型的数据转换成String。
	15.intern()
		为每一个唯一的字符序列生成且仅生成一个String引用。什么意思呢？就是说某一个字符序列已经存在的话，那么就返回该字符序列对应的引用

11.String、StringBuilder和StringBuffer

1.所有类似“ABC”的字面值，都是String类的实例。
2.字符串对象可以使用“+”连接其他对象，本质是创建了StringBuilder对象进行append操作，然后将拼接后的StringBuilder对象用toString方法处理成String对象。
3.String实例的值是通过字符数组实现字符串存储的。
4.String类实现了Serializable、CharSequence、 Comparable接口。
5.String是不可变字符序列，StringBuilder和StringBuffer是可变字符序列。
6.执行速度StringBuilder > StringBuffer > String。
7.StringBuilder是非线程安全的，StringBuffer是线程安全的。

12.反射机制

1.什么是反射机制？

• 在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取对象的各种信息。
• Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。

2.反射的原理

3.反射机制的作用？

• 通过反射可以使程序代码访问装载到JVM 中的类的内部信息
• 获取已装载类的成员变量信息
• 获取已装载类的方法
• 获取已装载类的构造方法信息

4.反射的基本使用

1.获得class
 通过class类的静态方法：forName(String className)
2.创建实例
 使用Class对象的newInstance()方法来创建Class对象对应类的实例。

Class<?> c = String.class;
Object str = c.newInstance();

3.获取构造方法
 1.批量的方法：
 public Constructor[] getConstructors()：所有"公有的"构造方法
 public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)
 2.获取单个的方法，并调用：
 public Constructor getConstructor(Class... parameterTypes):获取单个的"公有的"构造方法：
public Constructor getDeclaredConstructor(Class... parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有； 		
 3.调用构造方法：
Constructor-->newInstance(Object... initargs)
 4.获取成员变量并调用
 5.获取成员方法并调用