个人学习JAVA整理的一些小知识点，以及方便理解的例子（适合零基础）

窗口键 r，一起按下，输入cmd，可以打开dos界面
注意：在输入dos命令时，要使用英文输入，所有标点都是英文 d:
这是冒号的英文

面向过程，例如张三打篮球，还有在做一个李四踢足球的程序
面向对象，人的对象，人的运动的动作，运动的器械这三个对象
实例化一个张三的对象，对象有一个打篮球的动作，器械是篮球
实例化一个李四的对象，对象有一个踢足球的动作，器械是足球

面向对象能够更好的在抽象的层面来分析问题，在程序实现跨越极大的赋予之前的代码

c,c++ 由程序员回收，手动编写代码回收(优点：能够在内存在不使用时快速回收，准确高效；缺点：容易出现bug，例如忘记编写回收内存的代码？内存一直不回收)

java，垃圾回收是自动的，开了一个习题集线程自动去检测哪些内存不用了然后回收掉（优点：自动的，意味着不会出现忘记回收，缺点：回收不及时）

一般观点是，宁可回收不及时但是也一定要回收，使用自动的垃圾回收恒合适

正规的开发工作中，你之前的工作要求统一1.6.0.1.102，之后换了一个项目组，这个项目组要求使用1.8.0.1_103
可以先先卸载掉之前的jdk，根据需要安装新的jdk

你做技术核心同时支持三个项目，这三个项目分别使用不同版本的jdk
/**
*文档注释
*只是一个打印hello world的类
*@auther wdt
*@version1.0.0
*/

public class Test{
public static void main(String[]args){
//单行注释，打印hello world
System.out.print(“hello world”)
/*多行注释
下面准备写一个打印abc的程序
*/
System.out.print(“abc”)

}     

}

关键字：就是在java语言编程的时候，在关键的地方使用的单词，体现关键的地方的含义，这些单词都是特有的事先定义好的

保留字：可能在以后被用来作为关键字的单词，java已经把这些单词预定了，这些单词尽量就不要再编程中随意使用

标识符：abc_1$ 数字是不能开头的，不可以单独使用关键字，保留字 但是可以包含关键字或者保留字

java中的命名规范：
包类，多单词组成时所有字母都小写，xxxxxxyyyyyzzzzz
类名，接口名：多单词组成时，所有单词的首字母大写，XxxYyyZzz
变量名，方法名，多单词组成时，第一个单词首字母小写，第二个单词开始每个字母首字母大写，xxxYyyZzz
常量名，所有字母都大写，多单词时每个单词用下划线连接，XXX_YYY_ZZZ

代数，未知数的概念
java中变量的定义： 数据类型 变量名 = 变量值 ，例如 int i = 1

int i = 1
i = 2
注意：声明变量过程中的这个“=”，不是数学意义上的“=”，在java编程中代表赋值（赋予变量值）
在一对{}中有效 ，要变量初始化（第一次要给变量赋值）

变量的类型：声明的变量的数据类型就是变量的类型

数据类型：1.基本数据类型
（1）数值类型
（1.1）整数类型（byte，int，short，long） （1.2）浮点类型（float，double）
（2）字符类型（char）
（3）布尔类型（boolean）
2.引用数据类型
（1）类（class）
（2）接口（interface）
（3）数据（[]）

byte的范围在-128到127之间，声明byte类型变量的时候赋值不能超过这个范围，给byte类型变量赋值时不能超过这个范围

byte b = 130，这个就是超出范围了 就是错的

bit是个什么单位？
0100110，这个就是7bit

double d = 1.22
float f = 1.22f，float类型变量赋值时值后面跟上字母f

字符：用英文的单引号括起来的单个字母、数字、符号

比如：
char c1 = ‘a’
char c2 = ‘v’
char c3 = ‘@’

转义字符：\b（退格符）\n（换行符）\r（回车符）\t（制表符）"（双引号）’（单引号）\（反斜线）
比如 char c4 = ‘\n’

public class Test1{
public static void main(String[] args){
//System.out.print(“sss\n”);
//System.out.println(“sss”);

byte b = 1;
System.out.println(b);

short s =2;
System.out.println(s);

int i = 4;
System.out.println(i);

long l = 8;
System.out.println(l);

float f = 1.23f
System.out.println(f);

double d = 1.23
System.out.println(d);

char c ='c';
System.out.println(c);

boolean b1 = false;
System.out.println(b1);
    }

}

字符串就是由零到多个字母数字符号共同组成的一个串，这个串要用英文的双引号括起来

String str = “hello world”;
System.out.println(str);

引用类型，都可以用null作为值，也就是说在初始化的时候可以赋值为null
String是引用类型，也就是说可以使用null作为值

int i0 = 1;
int i1 = 1;
以上这种会在内存中存储2个1的值

String s0 = “hello”;
String s1 = “hello”;
以上这种不会再内存中存在两个“hello”，只会存在一个“hello”
假设“hello”的内存地址为xxxxx，声明s0变量时给s0赋值“hello”世界上就是让s0变量引用“hello”的内存地址xxxxx，当我们再次声明变量s1也赋值“hello”的时候，世界上也是直接把已经存在的“hello”的内存地址给s1引用

String s3 = “he”+“llo”;

当一系列的 + 的运算的时候，如果某个部分其中含有字符串，那么这个字符串前边挨着的 + 开始一直往后都是字符串拼接去看

byte b = 9;
int i = b;
以上属于正常隐式转换数据类型，自动

int k = 7;
byte b0 = (byte)k;
以上就是强制转换数据类型，转换的数据类型需要用英文的小括号括起来

创建一个java文件，用文本编辑器打开，写代码，打开dos界面，javac编译，java运行

集成开发环境就是为了解决上述问题，里面包含文本编辑工具，自动编译，简化运行，随时进行代码的调试

算数运算符
当整数除以整数的时候，会把结果的小数部分舍弃，只保留整数部分
7/2 = 3
7.0/2 = 3.5
i++(先运算+1 再取值）
++i(先取值，再运算+1）
字符串的加号是字符串之间的拼接

char类型数据是可以做数学运算的，在做数学运算的时候把字符转化为ASCII码进行运算
System.out.println(’’ + ‘\t’ + ‘*’); 答案：93

字符串与其他数据类型相加时，实际上是把其他数据类型转化为字符串，做字符串拼接
Ssytem.out.println("" + ‘\t’ + '’); 答案： *

赋值运算符

short s = 2;

*变量参与运算的时候，java程序不知道具体这个变量在昨晚运算后是否会超过当前变量范围，所有会把变量转换为一个更大长度，这个例子中，short是一个短整形数据，会转化为默认的int

s = (short)(s+3);

*在使用扩展赋值运算符时，变量在参与运算时会把结果强制转换为当前变量的类型
s += 3;

逻辑运算符

&和&&的区别：
&： 左边无论真假，右边都进行运算
&&：如果左边为真，右边参与运算，如果左边为假，右边不参与运算

”|“和“||“的区别与“&”相同

在不需要逻辑运算两边都参与运算的时候，尽量使用&&和||

int x=1,y=1;
if(x++2 & ++y2){

// x++2,x先取值后计算，12 ，结果是false，在计算++之后 x的值为2
// ++y2，y是先计算后取值，先计算++y得到的值为2，在逻辑判断y2 ，2==2，结果是true
// false & true 得到的结论是，false

x=7;

}
System.out.println(“x=”+x,“y=”+y);

位运算符

<< :空位补0，被移除的高位丢弃，空缺位补0

:被移位的二进制最高位是0，右移后，空缺位补0，最高位是1，空缺位补1

:被位移二进制最高位无论是0或者是1，空缺位都补0
&：二进制位进行&运算，只有1&1的时候结果是1，否则是0
|：二进制位进行|运算，只有0|0的时候结果是0，否则是1

^{：相同的二进制位进行}运算，结果是0；1^1=0，00=0
不相同二进制位^{运算结果是1；1}0=1,0^1=1

~：正数取反，各二进制码按补码各位取反
负数取反，个二进制码按补码各位取反

三位运算符
{条件表达式}？表达式1：表达式2：
为true，运算后的结果是表达式1；
为false，运算后的结果是表达式2；

int i = 1;
int k = i >0 ? 1 : 0;
System.out.println(k); #1

练习：获取两个数中的较大数
获取三个数中的较大数

int m = 1;
int n =2;
m >n ? m : n;

int k = 0;
System.out.println(k > m ?( k >m ? k : m ):(k > n ? k : n));

运算符的优先级
运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序

程序流程控制

顺序结构
程序从上到下逐行执行，中间没有任何判断和跳转

分支结构
根据条件，选择性的执行某段代码
有if…else和switch两种分支语句

int i = 1;
if(i == 1 ){
System.out.println(“星期一”);
}else if (i == 2){
System.out.println(“星期二”);
}else if (i == 2){
System.out.println(“星期三”);
}else{
System.out.println(“不知道星期几”);
}

循环结构
根据循环条件，重复性的执行某段代码
有while、do…while、for三种循环语句
注：JDK1.5之后提供了foreach循环，方便的便利集合，数组元素

public calss Test{
public static void main{String[] args){
for(int i = 0;i<5;i++){
System.out.println(“hello world”)
}
}
}

(2)while

int i = 1;
while(i <=100){
System.out.println(i); //获取变量 i <= 100 的技术结果，是true还是false，如果是true就执行while的大括号里面的代码，如果是false不执行
i++; //不断改变变量i的值
}

求1到100之间所有偶数的和
public class Test{
public static void main(String []args){
int sum = 0;
for(int i = 1; i<=100;i++){
if (i%2 == 0){
sum += i;
}
}
System.out.println(sum);
}
}

2.使用while
int sum2 = 0;
int i = 1;
while(i<=100）{
if(i % 2 == 0){
sum2 += i;
}
i++;
}
System.out.println(sum2);

无限循环

for (; 😉
while(true)

嵌套循环

for(int i = 0;i < 4; i++){ //每一次循环都会执行大括号里面的所有代码
System.out.println(“大循环—”+i);
for(int j = 0; j < 2; j++){ //大循环的次数乘以小循环的次数，就是小循环的大括号里面执行代码的次数）
System.out.println("大循环—”+ i + “小循环—” + j);
}
}
注意：在写嵌套循环的时候，尽量保证外层循环的循环次数小于内层的循环次数
在编写代码的时候，如果上面的for循环和底下的for循环可以达到同样的逻辑效果时，要尽量使用外循环次数小于内循环次数

打印九九乘法表
public class Test{
public static void main(String[]args){
for(int i =1 ; i <= 9; i++){
for(int j = 1 ; j <= i ; j++){
System.out.print(i + “*” + j +"=" +(i * j ); //print不换行
}
System.out.println(); //println换行
}
}
}

打印 1-100之间所有的质数 （质数是一个大于1的自然数，并且只能被1和本身整除）

//比如 7 ，循环1到7 ，用7与循环1到7之间的数分别取模，看能整除的次数，如果整除的次数只有2次，即可判断7是一个质数

for(int i = 1; i <= 100 ; i++){
int k = 0;
for(int j = 1; j <= i; j++){
if(i % j == 0){
k++;}
}
if (k == 2){
System.out.println(“质数:” + i);
}
}
}

特殊流程控制语句1
break;结束本次循环，当嵌套循环时，小循环中写break不会影响大循环
continue;结束当前循环，进入下次循环
return；是将整个方法结束

一维数组

int l1[] = new int[4] // 动态生成方式
l1[0] = 1;
l2[1] = 2;
使用动态初始化的时候，数组的元素会有默认值，数字类型的默认值为0，对象的默认类型是null

int l2[] = new int[]{0,1,2,3,}//静态生成方式

多维数组
//一维数组中每个元素都是一个数组，这样的数组就是二维数组
int l1 [][] = new int [][]{
{1,2},
{4,2}
}

int l1 [][] = new int [2][3]{ //第一维部分的长度为2，第二维度也就是第一位的每一个元素的长度是3
int l1 [][] = new int [2][] //第一维部分长度为2，第二维没定义

int[] x,y[]; //特殊写法，x是一维数组，y是二维数组
}

数组中涉及的常见算法

int arr[] = new int[]{4,2,5,3,7,1};
//最大值
int max = arr[0] //假设arr[0]是目前最大值
for (int i = 0;i<arr.length; i++){
if(max < arr[i]){
max = arr[i]; //存放目前最大值
}
System.out.println(max)
}

//最小值
int min = arr[0] //假设arr[0]是目前最大值
for(int i = 0;i < arr.length;i++){
if(min > arr[i]){
min = arr[i];
}
System.out.println(min)
}

//总和，平均数

int sum = 0;
for(int i = 0; i < arr.length; i++){
sum +=arr[i];
}
System.out.println(“总和:”+sum)
System.out.println(“平均数:”+(sum/arr.length)

//复制

int copy[] = new int [arr.length] //声明一个与arr长度一致的数组
for(int i = 0; i<arr.length;i++){
copy[i] = arr[i]
}

//反转
声明一个数组temp，数组temp的长度与arr的长度一致，我们倒着循环arr，正着给temp赋值

int temp[] = new int[arr.length];
int k = 0;
for(int i = arr.length-1; i>=0;i–){
temp[k] = arr[i];
k++;
}

//冒泡排序
int arr[] = new arr[]{6,13,54,2,1,0,9,84,23,58,66}
int temp[] = new temp[]{arr.length}
for(int i =0; i <arr.length-1;i++){
for(int j = 0; j<arr.length-i-1;j++){
if(arr[j] > arr[j+1]){
temp[j] = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp[j];
}
}
}

类的写法

publicc class person{
//属性，成员变量，类的成员变量可以先声明不用初始化，类成员变量是有默认值的
String name; //姓名，String类型的默认值是null
int age; //年龄，int默认值是0

//行为，也就是方法，也叫函数
public void showName(){ // 方法名称如果是多个单词，首个的单词的首字母小写，驼峰命名法

	System.out.println("姓名：“+ name);
}
public int getAge(){//如果是一个有返回值的方法，那么方法的最后一行一定是返回相应的数据，使用return关键字，返回的数据类型与方法定义的一致
	retrun age;
}

}

类的创建和使用
类的实例化

public class Test{
public static void main(String[] args){
//实例化Person类，也就是创建person对象
//int i = 0;
//String s = “”;
Person person = new Person();//声明一个Person类型的变量，变量名为person，实例化Person类并且给person赋值，赋值就是当前的实例
//new Person（）就是实例化Person类
person.name = “张三”;//给person对象的name属性赋值
person.showName();//对象的方法的调用
int i = person.getAge();//有返回值的方法，在调用之后就会有一个值，这个值就是方法中return的那部分
System.out.println(i);

person.age = 11;//给person对象的age属性赋值
int a = person.getAge();
System.out.println( a );

	
}

}
//未来可能会学习更多复杂的类，我们会给这些类创建对象，并且使用对象
//对于对象的使用无外乎就两个地方，操作对象的变量，调用类方法

类的属性

public class Person1{
public String name = “zhangsan”;
private int age; // private是私有的，可以在本类的方法使用，不能在类的外部使用
//修饰符可以用来修饰比变量，可以指明变量是公有还是私有
//实力变量就是在类实例化成对象后才能使用

public static String sex = "男”;//static ,意思是静态的，这样的变量不需要类实例化成对象就可以使用
//直接就可以通过类名，属性这样的方式直接调用，这样的变量叫类变量

}

成员变量（属性）和局部变量的区别？

成员变量：
成员变量定义在类中，在整个类中都可以被访问
成员变量分为类成员变量和实例成员变量，实例变量存在于对象所在的堆内存中。
成员变量有默认初始化值
成员变量的权限修饰符可以根据需要，选择任意一个

局部变量：
局部变量只定义在局部分为中，如：方法内，代码块内
局部变量存在于栈内存中
作用的范围结束，变量空间会自动释放
局部变量没有默认初始化值，每次必须显示初始化
局部变量声明时不指定权限修饰符

类的方法：类一个，通过实例化出来的对象可以多个，每个对象都是独立，互不干扰的

public class Student {
public String name;
public int age;
public String course;
public String interest;

/**
* 显示学生的个人信息
*/
public void showInfo(){
	System.out.println("姓名”+ name);
	System.out.println("年龄”+ age);
	System.out.println("课程”+ course);
	System.out.println("兴趣”+ interest);
}

}

Student stu = new Student();
stu.name = “张三”;
stu.age = 12;
stu.course = “数学”;
stu.insterest = “篮球，街舞，唱歌”;
stu.showInfo();

//同一个类中的所有方法 ，可以直接互相调用，不用new实例化对象

匿名对象使用方法
例：new Student().showInfo();即可使用

public class Person{
public String name;
public int age;
public int sex;
public void study(){
System.out.println(“studying”);
}
public void showAge(){
System.out.println(age);
}
public int addAge(int i){
age += i;
return age;
}
}

Person p = new Person();
p.name = “张三”;
p.age = 11;
p.sex = 0;
int a = p.addAge(2);
System.out.println(a);

/**

• 计算圆的面积

/
public class Circle{
/*
* 圆的面积计算方法
*@param r 园的半径
*@return
*/
public double area(double r){
return 3.14 * r * r;
}
}

double area = new Circle().area(2);
System.out.println(area);

/方法的重载

编写程序，定义三个重载方法并调用，方法名为mOL
三个方法分别接受一个int参数，两个int参数，一个字符串参数，分别执行平方运算并输出结果，相乘并输出结果，输出字符串信息
在主类的main（）方法中分别用参数区别调用三个方法

public void mOL(int i){
System.out.println(i*i);
}
public void mOL(int x,int y){
System.out.println(x * y);
}
public void mOL(string z){
System.out.println(z);
}

Test t1 = new Test();
t.mOL(2);
t.mOL(2,6);
t.mOL("重载方法mOL);

定义三个重载方法max（），第一个方法求两个int值中的最大值，第二个方法求两个double值中的最大值，第三个方法求三个double值中的最大值，并分别调用三个方法

public void max(int a,int b){
if(a>b){
System.out.print("最大值是”+ a)
}
else{
System.out.print("最大值是”+ b)
}
}

public void max(double x,doublc y){
if(x>y){
System.out.print("最大值是”+ x)
}
else{
System.out.print("最大值是”+ y)
}
}

public void max(double a ,double b ,double c){
double res = 0;
if (a>b){
if(a>c){
res = a;
}
else{
res = c;
}
}
else{
if(b>c){
res = b;
}
else{
res = c;
}
}
Test t2 = new Test();
t2.max(0,1)
t2.max(0.1,0.2)
t2.max(0.8,0.6,0.7)

体会可变个数的形参
形式：public static void main（String[]…args）{}

方法的参数传递方式
java的实参值如何传入方法？
java里方法的参数传递方式只有一种：值传递，即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响

基本数据类型，值保存在栈中，引用对象，值保存在堆中，栈中存的对象是堆中的地址

软件包
问题：在使用电脑的时候，如果不创建文件夹，所有的文件都直接放在D盘下面，行不行
首先，太乱，根本分不清哪些文件输入哪些软件
其次，同名文件，QQ的软件里面有一个名字叫data文件，微信里面也有一个名字叫data文件，那么如果都放在一个文件夹中，没办法处理同名文件的问题

在java中包的概念就是和文件夹的概念累死，同样，包的存在也是为了解决以上的问题（文件台联不好管理和文件同名）
java中的包package等同于文件夹的概念，包和文件夹一样可以有多级，也就是包下可以有包和文件，多级的包使用的.分隔. 例如com报下的cn包下的test包，写法为：com.cn.test

四种访问权限修饰符

修饰符 类内部 同一个包 子类 任何地方
private yes

(缺省) yes yes

protected yes yes yes

public yes yes yes yes

构造器也叫构造方法，既然是方法，就可以重载
构造器的重载，意义就是为了方便调用方可以灵活的创建出不同的需要的对象，重载的多个构造方法实际上就是相当于提供了多个初始化new对象的模板

关键字——this
当形参与成员变量重名的时候，如果在方法内部需要使用成员变量，必须添加this 来表明该变量时类成员
在任意方法内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性

注意：使用this（）必须放在构造器的首行
使用this调用本类中其他的构造器，保证至少有一个构造器是不用this的（实际上就是不能出现构造器自己调用自己）

继承
如果按照上面说的把代码写出来，如果直接硬写，代码重复的很多
首先编写父类代码（共性代码），子类继承父类的代码，省去共性代码，剩下的子类写自己特有的属性即可

注意：子类不是父类的子集，而是对父类的扩展

作用：
继承的出现提高了代码的复用性
继承的出现让类与类之间产生了关系，提供了多态的前提
不要仅为了获取其他类中的某个功能而去继承

人类{
姓名
性别
年龄

打印信息方法
}

学生类{
姓名
性别
年龄
学校

打印信息方法
}

工人类{
姓名
性别
年龄
工种

打印信息方法
}

教师类{
姓名
性别
年龄
科目

打印信息方法
}

方法的重写（override）
子类重写父类的方法，只是重新的编写方法体的代码
如果父类的方法是public，子类重写的时候，就不能使用缺省以下的
同为static或非static
如果子类和父类在用一个包下，那么对于父类的成员修饰符只要不是私有的private，那就都可以使用
如果子类和父类不在同一个包下，那么子类只能使用父类中protected和public修饰的成员

关键字this 和 super的区别
No 区别点 this super
1 访问属性 访问本类中的属性 访问父类中的属性
如果在本类没有此属性
则从父类中继续调查
2 调用方法 访问本类中的方法 直接访问父类中的方法
3 调用构造器 调用本类构造器，必须放在构造器的首行 调用父类构造器，必须放在子类构造器的首行
4 特殊 表示当前对象 无此概念

面向对象特征：多态
1.方法的重载（overload）和重写（overwrite）//重载：在本类中的同名方法，体现相同的名称方法实现，不同逻辑 重写：子类对父类方法的覆盖，子类可以使用和父类的相同的方法名，覆盖掉父类的逻辑（如果父类的方法， 想修改逻辑，但是有别的代码在调用父类的方法，可以考虑用子类继承父类，重新父类的方法）
2.对象的多态性–可以直接应用在抽象类的接口上

instanceof操作符
x instanceof A：检验x是否为类A的对象，返回值为boolean型
要求x所属的类与类A必须是子类和父类的关系，否则编译错误
如果x输入类A的子类B，x instanceof A 的值也为true
目的：检验某个对象是不是类A的子类

Object类
是所有java类中的跟父类（最顶层的父类，也叫基类）
如果在类的声明中未使用extends关键字指明其父类，则默认父类为Object类

对象类型的转换(Casting)
基本数据类型的Casting
自动类型转换：小的数据类型可以自动转换成大的数据类型
如 long g = 20; double d = 12.0f
强制类型转换：可以把大的数据类型强制转换成小的数据类型.
如float f =(float)12.0 int a = (int)1200L
对java对象的强制类型转换称为造型
从子类到父类的类型转换可以自动进行
从父类到子类的类型转换必须通过造型（强制类型转换）实现
无继承关系的引用类型间的转换时非法的

基本数据类型的包装类
基本数据类型与字符串之间的转换
int i = Integer.parseInt(“123”);
float i = Float.parseFloat(“0.40”);
boolean i = Boolean.parseBoolean(“false”);

String istr = String.value(i);
String fstr = String.value(f);
String bstr = String.value(true);

关键字 static
适用范围：
在java类中，可用static修饰属性，方法，代码块，内部类
被修饰后的成员具备以下特点：
随着类的加载而加载 #类加载之后，静态的方法或者属性就能用了，类名
优先于对象 #不用new就能使用
修饰的成员，被所有对象所共享
访问权限允许时，可不创建对象，直接被类调用

单例（Singleton）设计模式
只有一个实例（实例化对象）
在整个软件系统运行过程中，这个类只被实例化一次，以后不论在哪都只调用这一个实例
例如实例化对象的创建要消耗大量的时间和资源
能解决什么问题？
一般都是new对象太费劲，或者频繁的new新的对象没有必要
单例模式，软件的运行有且只有一个实例化对象，（只会new一次）

懒汉式和饿汉式的区别，就是什么时候new这个对象
懒汉式：在第一次调用getInstance方法的时候new对象，以后每一次调用，直接就返回new好的对象
饿汉式：在类加载之后，还没有人调用的时候，就先new好一个对象，以后每一次调用getInstance方法都直接返回new好的方法

关键字final

final代表最终，可以修饰变量，方法，类
修饰变量，即为常量，只能赋值一次，不能改变
修饰方法，子类不能重写
修饰类，类不能继承

抽象类
用abstract关键字来修饰一个类时，这个类叫抽象类
用abstract来修饰一个方法时，该方法叫做抽象方法
抽象方法：只有方法的声明，没有方法的实现，以分号结束：abstract int abstractMethod(int a);
含有抽象方法的类必须被声明为抽象类
抽象类不能被实例化，抽象类时用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体，若没有重新全部的抽象方法，仍为抽象类
不能用abstract修饰属性，私有方法，构造器，静态方法，final的方法

模板方法设计模式（TemplateMethod）
抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展，改造，但子类总体上会保留抽象类的行为放

解决问题：
当功能内部一部分实现是确定，一部分实现是不能确定的，这时可以把不确定的部分暴露出去，让子类去实现
编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式

接口
抽象类是对于一类事物的高度抽象，其中既有属性也有方法
接口是对方法的抽象，也就是对一些列动作的抽象

当需要对一类事物进行抽象的时候，应该使用抽象类，形成一个父类
当需要对一些列的动作进行抽象的时候，应该使用接口，需要使用这些动作的类，去实现相应的接口

缓冲流
FileInputStream,FileOutputStream
FileReader,FileWriter
这些都是计算机与硬盘之间发生的io操作，基于硬盘的读写相对是比较慢的，这个操作的速度受硬盘的读写速度的制约，为了能够提供读写速度，一定程度上绕过硬盘的限制，JAVA提供一种缓冲流来实现

缓冲流就是先把数据缓冲到内存里，在内存中去做io操作，基于内存的io操作大概能比基于硬盘的io操作快75000多倍

流的基本应用小节

流是用来处理数据的
处理数据时，一定要先明确数据源与数据目的地
数据源可以是文件，也可以是键盘
数据的目的地可以使文件，显示器或者其他设备

而流只是在帮助数据心境传输，并对传输的数据进行处理，比如过滤处理，转换处理等

反射，
反射相关的主要API
java.lang.Class代表一个类
java.lang.reflect Method代表类的方法
java.lang.reflect.Field代表类的成员变量
java.lang.reflect.Constructor代表类的构造方法

线程

程序，是为了完成特定的任务，用某种语言编写的一组指令的集合，即指一段静态的代码，静态的对象

进程，是程序的一次执行过程，或是正在运行的一个程序
动态过程，有它自身的产生，存在和消亡的过程

线程，进程可进一步细化为线程，是一个程序内部的一条直行路径

线程的生命周期
新建，就绪，运行，阻塞，死亡