走一遍Java那些基础

数据类型

标识符

在Java中，我们需要标识代码的很多元素，包括类名、方法、字段、变量、包名等。
我们选择的名称就称为标识符，并且遵循以下规则：
A. 标识符可以由字母、数字、下划线（_）、美元符（$）组成，但不能包含 @、%、空格等其它特殊字符。
B. 不能以数字开头。
C. 标识符是严格区分大小写的。
D. 标识符的命名最好能反映出其作用，做到见名知意。

注释

Java代码的解释说明。不影响程序的运行，用于辅助读程。

//单行注释
/* 多行注释 /
/* 文档注释 */

变量

在JAVA中，有的数据值是不固定的，总在变，我们还需要记录这些值，我们可以把这些值理解为变量。

注意：
1、 变量名必须是一个有效的标识符。
2、 变量名不可以使用java关键字
3、 变量名不能重复

常量

在程序运行过程中一致不会改变的量成为常量。

基本类型(八种)

基本类型的转换

运算符

概述

分支结构

概述

顺序结构的程序虽然能解决计算、输出等问题，但不能做判断再选择。

对于要先做判断再选择的问题就要使用分支结构。

if和switch

循环结构

for

概述

循环结构是指在程序中需要反复执行某个功能而设置的一种程序结构。
它由循环体中的条件，判断继续执行某个功能还是退出循环。
根据判断条件,循环结构又可细分为先判断后执行的循环结构和先执行后判断的循环结构。

形式

for( 开始条件 ; 判断条件 ; 更改条件 ){

    循环体;

}

三种循环的区别

三种循环结构的语法，可以互相替换。
1, for(开始条件；判断条件；更改条件){ 循环体 }
2, while(判断条件){循环体}
3, do{ 循环体} while(判断条件);

for形式要求：知道从哪儿开始，循环多少次
不知道从哪儿开始，不知道要执行多少次，用while或者do while

while形式：先判断，再执行
do while形式：先最少执行1次，再判断
方法

概述

被命名的代码块main(){ }
可以含参数可以不含参数
可以提高代码的复用性。

形式

修饰符  返回值  方法名  ( [参数列表] ){

    方法体

}

方法的重载

概念

方法重载是指在一个类中定义多个同名的方法，
但要求每个方法具有不同的参数列表(也就是说参数的个数和类型不同)。
程序调用方法时，可以通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法。

package com.tedu.xh;
/**
 * 测试方法重载
 * @author Tongtao
 *
 *
 */
public class Test1 {
	public static void main(String[] args) {
		add(5);
		add("jack", 5);
		add(10, "rose");

	}
	public static void add(int a,String b) {
		
		System.out.println(a+b);
	}
	public static void add(String a,int b) {
		
		System.out.println(a+b);
	}

	public static void add(int a) {
		
		System.out.println(a*a);
	}

}

冒泡排序

概念

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。
这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

测试冒泡排序的代码:

package com.tedu.xh;

import java.util.Arrays;
import java.util.Random;

public class Test2 {
	public static void main(String[] args) {
		int[] arr=suiji();//获得随机数组
		System.out.println(Arrays.toString(arr));
		
		sort(arr);
		System.out.println(Arrays.toString(arr));

	}
	
	//获得随机数组
	private static int[] suiji() {
		int n=5+new Random().nextInt(6);
		int[] arr=new int[n];
		for(int i=0;i<arr.length;i++) {
			
			arr[i]=new Random().nextInt(100);
		}
		return arr;
	}
	
	
	//定义冒泡排序方法，从小到大排序
	private static void sort(int[] a) {
		for(int i=0;i<a.length;i++) {
			
			for(int j=a.length-1;j>i;j--) {
				if(a[j]<a[j-1]) {
					int t=a[j];
					a[j]=a[j-1];
					a[j-1]=t;
				}
			}
		}
	}

}

数组和变量

数组

概念

数组Array。标志[ ]。
是用于储存多个相同类型数据的集合。
想要获取数组中的元素值，可以通过脚标（下标）来获取，下标是从0开始的。

创建数组

动态初始化
int[] a = new int[10];

静态初始化
int[] b = new int[]{1,2,3,4,5};
int[] c = {1,2,3,4,5};

数组工具类Arrays

Arrays.sort(数组)

Arrays.toString(数组)

Arrays.copyOf(原数组，新的长度)

变量

概念

可以改变的数，称为变量。一般通过三部分来描述一个变量。
变量类型，变量名，变量值。其中三部分都是可以改变的，根据需要来确定即可。
变量的使用原则：就近原则。尽量控制到最小范围。

局部变量

定义在方法里，或者局部代码块中。
注意：必须手动初始化，来分配内存。如：int i=5; 或者 int i; i=5;
作用域也就是方法里或者局部代码块里，方法运行完内存就释放了。

成员变量

定义在类里，方法外。
注意：不用初始化，也会自动被初始化成默认值。
作用域是整个类中，类消失了，变量才释放。

测试代码

package com.tedu.xh;

public class Test3 {
	
	///成员变量：1，位置：在类里方法外
	//2,不需要手动初始化也会有默认值  
	//3，作用范围是在整个类里
	
	static int sum;
	public static void main(String[] args) {
		
		
		//局部变量
		int count=10;
		System.out.println(count);
		
		int sum=20;
		System.out.println(sum);
	}

}

Static

概念

是java中的一个关键字
用于修饰成员（成员变量和成员方法）

特点

1、 随着类的加载而加载
2、 只加载一次，就会一直存在，直到类消失就一起消失了
3、 优先于对象加载
4、 被所有对象所共享
5、 可以直接被类名调用

测试代码

package com.tedu.xh;

public class Test5 {

	public static void main(String[] args) {
		Person.game();
		System.out.println(Person.age);
	
		Person p=new Person();
		p.eat();
		System.out.println(p.name);
		
		p.game();
		System.out.println(p.age);
		
		Person.game();
		System.out.println(Person.age);
		
		Person p1 = new Person();
        Person p2 = new Person();
        p1.age=10;
        System.out.println(p2.age);//10
		

	}
	
	static class Person{
		
		String name;
		public void eat() {
			System.out.println("eat()....");
		}
		
		//静态资源--使用static修饰
		static int age;
		static public void game() {
			System.out.println("game()...");
		}
	}

}

静态代码块、构造代码块、局部代码块

1、 静态代码块：在类加载时就加载，并且只被加载一次，一般用于项目的初始化
2、 构造代码块：在创建对象时会自动调用，每次创建对象都会被调用
3、 局部代码块：方法里的代码块

测试代码

package com.tedu.xh;

public class TestBolock {

	public static void main(String[] args) {
		TestBlock tb=new TestBlock();
		tb.show();
		TestBlock tb2=new TestBlock();
	}
}
class TestBlock{
	
	//1.提供构造代码块
	{
		System.out.println("构造代码块");
	}
	
	//2.提供静态代码块，加载的早，而且只加载一次
	
	static {
		
		System.out.println("静态代码块");
	}
	
	//提供构造方法
	
	public TestBlock() {
		System.out.println("构造方法");
	}
	
	
	//4.提供局部代码块
	
	public void show() {
		{
			System.err.println("局部代码块");
		}
	}
}

final

概念

1、 是java提供的一个关键字
2、 final是最终的意思
3、 final可以修饰类，方法，成员变量
初衷是因为：java出现了继承后，子类可以更改父类的功能，当父类功能不许子类改变时可以利用final关键字修饰父类。

特点:

1、 被final修饰的类，不能被继承
2、 被final修饰的方法，不能被重写
3、 被final修饰的变量，是个常量，不能被改变
4、 常量的定义形式：final 数据类型 常量名 = 值

多态

概念

多态指同一个实体同时具有多种形式。
它是面向对象程序设计（OOP）的一个重要特征。
主要是指同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。
好处是可以把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异。
写出通用的代码，做出通用的编程，统一调用标准。

特点

1、 多态的前提1：是继承
2、 多态的前提2：要有方法的重写
3、 父类引用指向子类对象,如：Animal a = new Dog(); – 小到大，向上转型
4、 多态中，编译看左边，运行看右边

多态的好处

1、 多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法
2、 提高了程序的扩展性和可维护性

异常(了解)

概述

用来封装错误信息的对象。
组成结构：类型，提示，行号

异常的集成结构

Throwable - 顶级父类

-- Error：系统错误，无法修复

-- Exception：可修复的错误

-- RunTimeException

-- ClassCastException

-- ClassNotFoundException

异常处理

程序中遇到了异常，通常有两种处理方式：捕获 或者 向上抛出。
当调用了一个抛出异常的方法时，调用位置可以不做处理继续向上抛出也可以捕获异常。

抽象类

概念

Java中可以定义没有方法体的方法，该方法由其子类来具体的实现。
该没有方法体的方法我们称之为抽象方法，含有抽象方法的类我们称之为抽象类。
抽象类可以理解为是一个只有方法声明没有方法体的特殊类。

修饰符 abstract 返回值 方法名(参数列表);

接口

概念

Java里面由于不允许多重继承，所以如果要实现多个类的功能，则可以通过实现多个接口来实现。

interface 接口名{  代码…  }

特点

1、 接口中都是抽象方法
2、 通过interface关键字创建接口
3、 通过implements让子类来实现
4、 可以理解成，接口是一个特殊的抽象类
5、 接口突破了java的单继承的局限性
6、 接口和类之间可以多实现，接口和接口之间可以多继承
7、 接口是对外暴露的规则，是一套开发规范
8、 接口提高了程序的功能扩展，降低了耦合性

单列设计模式

概念

单例模式可以说是大多数开发人员在实际中使用最多的，常见的Spring默认创建的bean就是单例模式的。单例模式有很多好处，比如可节约系统内存空间，控制资源的使用。其中单例模式最重要的是确保对象只有一个。

BigDecimal/BigInteger

概述

BigDecimal:常用来解决精确的浮点数运算
BigInteger:常用来解决超大的整数运算

创建对象

BigDecimal.valueOf(2);  //最好别用double参数的。

常用方法

add(BigDecimal bd)： 做加法运算
subtract(BigDecimal bd) ： 做减法运算
multiply(BigDecimal bd) ： 做乘法运算
divide(BigDecimal bd) ： 做除法运算
divide(BigDecimal bd,保留位数,舍入方式)：除不尽时使用
setScale(保留位数，舍入方式)：同上
pow(int n)：求数据的几次幂

IO简介

继承结构

in/out相对于程序而言的输入(读取)和输出(写出)的过程。

java.io包：

File

字节流：针对二进制文件

InputStream

--FileInputStream
--BufferedInputStream
--ObjectInputStream
OutputStream

--FileOutputStream
--BufferedOutputStream
--ObjectOutputStream

字符流：针对文本文件。读写容易发生乱码现象，在读写时最好指定编码集为utf-8

Writer

--BufferedWriter
--OutputStreamWriter

Reader

--FileReader
--BufferedReader
--InputStreamReader
--PrintWriter/PrintStream

流的概念

数据的读写抽象成数据，在管道中流动。

Ø 流只能单方向流动

Ø 输入流用来读取in

Ø 输出流用来写出Out

Ø 数据只能从头到尾顺序的读写一次

File文件流

概述

封装一个磁盘路径字符串，对这个路径可以执行一次操作。
可以用来封装文件路径、文件夹路径、不存在的路径。

创建对象

File(String pathname)
          通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。

常用方法

length()：文件的字节量
exists()：是否存在，存在返回true
isFile()：是否为文件，是文件返回true
isDirectory()：是否为文件夹，是文件夹返回true
getName()：获取文件/文件夹名
getParent()：获取父文件夹的路径
getAbsolutePath()：获取文件的完整路径

创建、删除

createNewFile()：新建文件，文件夹不存在会异常，文件已经存在返回false
mkdirs()：新建多层不存在的文件夹\a\b\c
mkdir()：新建单层不存在的文件夹\a
delete()：删除文件，删除空文件夹

字节流读取

字节流是由字节组成的,字符流是由字符组成的. Java里字符由两个字节组成.字节流是最基本的，所有的InputStream和OutputStream的子类都是，主要用在处理二进制数据。

InputStream抽象类

abstract  int read()
          从输入流中读取数据的下一个字节。

 int read(byte[] b)
          从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。

 int read(byte[] b, int off, int len)
          将输入流中最多 len 个数据字节读入 byte 数组。

void close()
          关闭此输入流并释放与该流关联的所有系统资源。

FileInputStream子类

FileInputStream(File file)

          通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。

FileInputStream(String pathname)
          通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。

BufferedInputStream子类

BufferedInputStream 为另一个输入流添加一些功能，即缓冲输入以及支持 mark 和 reset 方法的能力。
在创建 BufferedInputStream 时，会创建一个内部缓冲区数组(默认8K大小)。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。