Java基本

1.Java基础

1.1基础概念/语法

面向对象（继承、封装、多态）基础、包、类、接口、方法、对象、属性、第一个 Java 程序。

1.2数据类型

1）基本数据类型8种：byte、short、int、long、float、double、char、boolean；2）引用数据类型

1.3变量类型

局部变量、实例变量（成员变量）、类变量（静态变量）

1.4修饰符

public、private、不写、protected、static、final、abstract、synchronized ，volatile

1.5运算符

1）算术运算符：+、-、、/、%、++、–；2）关系运算符：==、!=、>、<、>=、<=；3）逻辑运算符：&&、||、!；4）赋值运算符：=、+=、-=、=、/=；5）条件运算符：Object x = (expression) ? value if true : value if false；

其他常见需要掌握的

循环结构：for 循环、while 循环、do…while 循环

条件语句：if…else、if…else if…else

异常处理：try…catch…finally、throws、throw

字符串：String、StringBuilder、StringBuffer

其他：switch case、数组、日期时间、枚举、使用 IDE 进行 DEBUG
JAVADOC文件
/**@author 作者名
*@version 版本号
*@since 指明需要最早使用的jdk版本
*@param 参数名
*@return 返回值情况
*@throws 异常抛出情况
*/
Tools–>Generate JavaDoc
Files:选择是整个项目还是模块还是单个文件
Output directory:文档输出路径
Locale :选择地区，这个决定了文档的语言，中文就是zh_CN

Other…JavaDoc的参数，一般这样写 -encoding UTF-8 -charset UTF-8 -windowtitle “文档HTML页面标签的标题” javaDOC

Scanner

Scanner s =new Scanner(System.in);//创建一个s对象
s.hasNext;//判断输入后面是否有东西-Int，float，double，...
s.hasNextLine;
s.next()//读取到有效字符串后结束输入，前面遇到空格会自动抹去，后面遇到的空格会作为结束符空格之后的读取不到
s.nextLine()//同上但是可以获取空白回车作为结束符
s.close();

增强for

for（x：…）
java5引入
用于数组、集合

方法

一个方法就完成一个功能//类似C/C++函数

修饰符 返回值类型 方法名（开头小写后面大写）（参数类型 参数名）{
方法体
return 返回值；
}

调用：对象名.方法名（实参） 作为一个值 或者为一个语句
重载：同名函数 参数列表不同（个数、类型、顺序）返回类型可以相同也可不同

可变参数只能放在最后
public static void printMax(double … numbers)

递归

自己调用自己，但是不适合大量计算在一定程度上可以提高效率
但是要考虑是否会溢出

数组

相同数据类型的有序集合

int [ ] nums;
int nums[ ]; //动态初始化int [ ] nums = new int [10]  
nums.length//多少行多长
nums[i].length//多少列
nums = new int[10];
nums [0]=1216;

int [ ] a={ 1，2，1，2，3，6，6，6 }//静态初始化
 for-each//jdk1.5，没有下标
 for（int a ：a）
 

二维数组

Arrays.sort()//数组排序
Arrays.fill()//数组填充0
 冒泡：O(n^2)
 int temp=0;
 for(int i =0 ;i<array.length-1;i++){
 if （array[j+1]<array[j]）{
 temp=array[j];
 array[j]=array[j+1];
 array[j+1]=temp;
   }
}

类和对象

类是对于某一类事物的整体描述
对象是类的实例化
以类的方式组织代码，一对象的方式组织封装数据
new关键字创建的时候会自动初始化

构造器：和类名相同、没有返回值

作用：new的时候本质在调用构造器、初始化对象的值

引用类型：
对象是通过引用来操作的：栈—>堆

属性：
默认初始化 0 0.0 、char u000
Boolean：false
引用：null
修饰符 属性值 属性名 = 属性值！
对象的创建和使用：
必须使用new关键字创建对象， Person sk = new Person();
对象的属性 sk.name
对象的方法 sk.eat();
类：
静态的 属性
动态的 方法

封装

		提高程序安全性 保护数据
		隐藏代码细节
		统一接口
		系统可维护性提高了

高内聚低耦合
private 私有的
public 公有的
alt+insert自动写一些/get set方法

继承

所有的类都直接或者间接的继承了object类
java中只能单继承，一个儿子只能有一个爸爸但是一个爸爸可以有多个二组
子类 extends 父类
public 、protected可以被继承
private·无法被继承

Super//this调用父类的构造器必须放在代码的第一行
super注意点:

	1. super调用父类的构造方法，必须在构造方法的第一个
	2. super 必须只能出现在子类的方法或者构造方法中!
	3. super和 this 不能同时调用构造方法!

Vs this:
代表的对象不同:
this:本身调用者这个对象
super: 代表父类对象的应用

前提this:没有继承也可以使用
super:只能在继承条件才可以使用

构造方法this();本类的构造super():父类的构造!

方法重写

子类重写父类方法
方法名必须相同
参数列表也要相同
修饰符范围可以扩大但不能缩小public>protected>default>private
抛出异常 范围可以缩小不能扩大 ClassNotFoundException—>Exception(大)
为什么重写？
1.父类的功能子类不满足或者不需要
Alt+Insert：overside

多态

定义：即同一方法可以根据发送对象的不同而采用多种不同的行为方式。一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
父类的引用指向子类对象

多态存在的条件：
有继承关系
子类重写父类方法
父类引用指向子类对象

注意:多态是方法的多态，属性没有多态性。
instanceof

1.多态的方法的多态属性没有多态
2.父类和子类有关系 类型的转换异常
3.存在条件 继承关系方法需要重写，父类应勇指向子类对象
4.父类引用指向子类的对象
5.把子类转换为父类,向上转型;
6.把父类转换为子类，向下转型;强制转换
7.方便方法的调用，版少重复的代码!简洁

static{
静态代码块
}//只执行一次

抽象类

关键字：abstract
继承了抽象类的子类必须实现他的方法，不能new
接口可以多继承

abstract 抽象类 : 类 extends  : 单继承~  (接口可以多继承)
public abstract class Action {

//abstract ，抽象方法，只有方法名字，没有方法的实现!
public abstract void doSomething();
//1．不能new这个抽象类，只能靠子类去实现它;约束!
//2．抽象类中可以写普通的方法~
//3．抽象方法必须在抽象类中～
//抽象的抽象:约束~

//存在的意义―抽象出来~提高开发效率
}

接口

普通类:只有具体实现
抽象类;具体实现和规范(抽象方法)都有!
接口:只有规范!自己无法写方法
专业的约束!约束和实现分离:面向接口编程

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java、c#等)，就是因为设计模式所研究的，实际上就是如何合理的去抽象。
声明类的关键字是class,声明接口的关键字是interface

实现了接口的类要实现里面的方法
接口里面定义的方法都是抽象的

作用:
1．约束
2．定义一些方法，让不同的人实现～10—>13. public abstract
4. public static final
5．接口不能被实例化，接口中没有构造方法
6. implements可以实现多个接口
7.必须要重写接口中的方法

内部类：可以获得外部类的私有属性
静态内部类不行

异常

异常体系结构
Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类。在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception

异常的分类
异常(Exception)

编译时异常: 凡是Exception或者是Exception的子类都成为编译时异常,这种是可以解决的,一般编译不通过

运行时异常: 凡是RuntimeException或者是RuntimeException的子类都成为运行时异常,这种也是可以解决的,一般都是代码不够严谨或者逻辑错误

错误 (Error)我们无法解决,这不是我们所关心

我们处理异常的方式

1.try…catch…finally

2.throws

try…catch…finally异常处理方法
*try…catch…finally异常处理的格式*:
try {
可能出现问题的代码;
} catch(异常类名 异常对象) {
异常处理的代码
} finally {
释放未关闭的资源 
}

try…catch…finally执行流程：

1.程序执行到错误代码的地方,系统会抛出一个异常对象

ArithmeticException ae = new ArithmeticException(“/by zero”);

throw ae;

2.程序转入catch块进行逐个匹配

3.匹配成功,程序执行 catch代码

4.匹配失败,程序还给JVM处理

注意事项

try块代码尽量越少越好

一旦try块代码中出现异常,无论try块后面有多少行代码,都不会被执行

catch块中异常参数匹配同样满足多态 Exception e = new ArithmeticException(“/by zero”);

try块只能够有一个,catch可以有多个,try可以和finally组合,try可以和catch组合,try可以和catch和finally组合

一般会把Exception作为catch的参数类型放在异常处理格式的最后

Execption作为父类异常参数只能够出现在异常的最后面,先子类后父类

finally修饰的代码块一定会被执行，除非在执行到finally之前程序异常退出或者调用了系统退出的方法。

Exception
在Exception分支中有一个重要的子类RuntimeException(运行时异常)
ArraylndexOutOfBoundsException(数组下标越界)
NullPointerException(空指针异常)
ArithmeticException(算术异常)
MissingResourceException(丢失资源)
ClassNotFoundException(找不到类）等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。
这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生;
Error和Exception的区别: Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机(JVM)一般会选择终止线程;Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。

…try监控杆区域
catch捕获异常Ctrl+ALt+t

自定义异常
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。
在程序中使用自定义异常类，大体可分为以下几个步骤:
1．创建自定义异常类。
2．在方法中通过throw关键字抛出异常对象。
3．如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理;否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。4、在出现异常方法的调用者中捕获并处理异常。

---

经验总结

---

处理运行时异常时，采用逻辑去合理规避同时辅助 try-catch处理
在多重catch块后面，可以加一个catch (Exception)来处理可能会被遗漏的异常对于不确定的代码，也可以加上try-catch，处理潜在的异常
尽量去处理异常，切忌只是简单地调用printStackTrace()去打印输出具体如何处理异常，要根据不同的业务需求和异常类型去决定
尽量添加finally语句块去释放占用的资源