JAVA心得
JAVA对大小写十分敏感，是强类型语言
IDE短语
psvm==> public static void main(String[] args) { 建立方法
sout==>System.out.println(); 输出（有换行）
sout==>System.out.print(); 输出（无换行）
sout==>System.out.println(（int）c2); 强制转换 输出（有换行）
注释（同C++）
单行注释==>//
多行注释==>/* */
文档注释 ==>/** */
参数信息：@author 作者名
@version 版本号
@since 指明需要最早使用的jdk版本
@param 参数名
@return 返回值情况
@throws 异常抛出情况
数据类型
数值类型
整数类型
整数
byte==>占1个字节范围：-128————127
short==>占2个字节范围：-32768-——————32767
int==>占4个字节范围：-214743648-——————2147483647
long==>占8个字节范围 Long类型要在数字后后面加个L
浮点类型 （小数）离散 舍入误差 大约 接近但不相等
float==>占4个字节范围 要在数字后后面加个F
double==>占8个字节范围
最好完全避免避免使用浮点数比较
银行业务表示钱不能用浮点数（浮点数误差），用BigDecimal 数学工具类
字符类型
单字符char==>占2个字节范围
String是字符串，但是String不是关键词，是类
boolean类型布尔值
占1为其值只有true和false两种
boolean flag = true;
引用类型
类
接口
数组
进制
二进制0b 0b1
八进制0 010
十六进制0x 0x10
类型转换
运算中，不同类型的数据先转化为同一类型，然后进行运算
强制转换 高==>低
自动转换 低==>高
转换的时候可能会内存溢出或者精度问题
低———————————————------------—————————>高 byte,short,char->int->long->float->double
变量
局部变量（方法内部设变量）
实例变量（方法外部设变量）
从属于对象，如果不自行赋值则会输出默认值0 0.0 null
//布尔值的默认值是false
int age；
public static voif main(String[] args){
Demo08 demo08 = new Demo08();
System.out.println(demo08.age);
}//暂时不详细了解，平时用类变量代替
类变量（前面加上static，外部）
常量
final 常量名=值
final double PI=3.14;
可变参数
为避免方法重载过多，采用不定向参数
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在他之前声明
public void test(int... i){
}//由于不知道会有几个int数，所以直接采用可变参数
数组
int[] nums;//定义一个int类型的数组 nums = new int[10];//将这个数组设定为10个内容
获取数组长度方法 arrays.length
冒泡排序
import java.util.Arrays;
public class 冒泡排序 {
public static void main(String[] args) {
int [] a={1,331,12,14,54,75,3};
int[] sort=sort(a);
System.out.println(Arrays.toString(sort));
}
public static int[] sort(int []array) {
int temp = 0;
for (int i = 0; i < array.length - 1; i++) {
//外层循环，一共有多少个数字就循环多少次
for (int j = 0; j < array.length - 1; j++) {
//内层循环，每进行一次下一次循环少进行一步
if (array[j + 1] > array[j]) {
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
return array;
}
}
稀疏数组
如果一个数组里面的大部分元素为0或同一值；则可以采用此方法
处理方式：
1，记录数组一共有几行几列，有多少不同值。
2，把具有不同值的元素和行列及值记录在一个小规模的数组中
数组【0】用于记录行数列数与有多少不同值，余下数组记录值与他的位置
命名规范
1.只能由字母，数字，下划线，美元符号组成
2.不能以数字开头
3.区分同一个字母的大小写，即 hello 和 Hello 是不同的标识符
Java标识符一般有以下规范：
1.包名：全小写，如 java.awt.event, test
2.类名：首字母大写，如果由多个单词组成，要求每个单词的首字母都大写，如 HelloWorldApp
3.接口名：命名规则与类名相同。
4.方法名：往往由多个单词合成，第一个为动词，因此动词要全小写，后面的单词首字母大写，如
balanceAccount、isButtonPressed
5.变量名：一般为名词，全小写，如 area，lenth
6.常量名：全大写，如 MAX_INT, YEAR
7.对于变量名和方法，标识符不宜以“_” 和 “$” 为第一个字符，这两个字符对内部有特殊含义。
变量的命名规范
1.类成员变量：首字母小写和驼峰原则 monthSalary
2.局部变量：首字母小写和驼峰原则
3.常量：大写字母和下划线MAX_VALUE
4.类名：首字母大写和驼峰原则Man，GoodMan
5.方法名：首字母小写和驼峰原则 run（），runRun（）
面向对象OOP
一个项目应该只存在一个main方法
new代码的理解（自己理解的）
Pet dog = new Pet(); 对象类型 对象名=new 对象值 对象值实例化引出了他的一个对象dog， dog含有对象值的属性和方法 堆中的dog会调用方法区中对象类型的方法 所以方法最终一般是与左边有关 对象类型的变化其实就是多态，其本质就是子类继承了父类的方法，所以子类的对象可以调用父类的方法
方法设置
修饰符 返回值类型 方法名（参数）
没有返回值，则写入void；可以不写return或者只写return
静态
和类一起加载的
在其他类调用时只需要打 类名.方法名 即可
非静态
实例化new后才存在
在其他类里调用时，先将其实例化再用静态的调用方法
类
类实例化后会返回一个自己的对象
属
默认初始化：
数字：0 0.0
char：u0000
boolean：false
引用：null
属性格式：修饰符 属性类型 属性名=属性内容
修饰符public>default(默认)>protected>private
构造器 public 类名（）
一个类即使什么都不写，他也会存在一个方法
使用new，必须要有构造器，隐藏存在的是一个无参构造器。如果类里面有含参构造器，则使用无参构造器时无参构造器不能隐形
alt+insert快速生成一个构造器
要求
1.和类名相同
2.没有返回值
作用
1.new本质在调用构造方法（当同时包含有参构造和无参构造时，输入不同，调用的构造器不同）（程序走到new行代码后，会去类中找到复合的构造器并执行）
new Person();//调用无参构造 new Person(浩衡)；//调用有参构造public Person(String name),浩衡就是输入构造器的name。此时在构造器中进行this.name = name;可以将浩衡赋给Person一个对象的属性name
2.初始化对象的值（非常重要，在无参构造器中通过this将类的属性赋予初始值）
注意点：
1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
this.name代表这个类的一个属性name
封装 可以隐秘的进行合法检查
提高程序安全性，保护数据
隐藏代码的实现细节
统一接口
系统可维护性增加
高内聚，低耦合
属性私有（private int a;），get/set
私有的属性不能用s1.name这样去调用对象s1中的属性name
可以操作私有的方法:
get获得这个数据
set给这个数据设置值
在s1类里面
public String getName()
{
return this.name;
}//设置获取数据的方法
public void setName(String name){
this.name=name;
}//设置数据
在主类里面
String name=s1.getName();
s1.setName("xx");
alt+insert可以快速设置get/set 选择getter and setter
&&&继承extends
在java中，所有类都直接或间接继承object类
a extends b;
public：子类继承父类的全部方法，属性（父类与子类有相同名字的属性时，子类.属性名调用的是子类的属性）
private无法继承
ctrl+H可以打开继承树
一般父类的属性采用private不进行继承，同时设置get/set，将这两个方法继承给子类。这样在实例化子类后，可以同时使用父类与子类的属性
java采用单继承，一个子类只能有一个父类。父类可以有多个子类。但是接口可以多继承
被final修饰的类不能有子类
super
this.xxx 调用该类里面的属性和方法
super.xxx 调用父类的属性与方法 私有无法被继承
调用父类的构造器必须在子类的第一行、
无参构造第一行有隐藏super，会调用父类的无参构造
父类没有无参，子类也不能有无参
super与this不能同时调用构造
this
调用本身
&&&重写override 需要是非静态方法
重写都是方法的重写
避免重写就用static
父类的引用指向子类
父类 b=new 子类();
最终用的时子类
重写的修饰符范围可以扩大protected==>default==>public
静态方法：方法的调用只和左边的数据类型有关
&&&多态
一个对象的实际类型是确定的，但是他的指向类型是不确定的
多态是方法的多态，属性没有多态
要有父子类型才能进行高转低 ClassCastException类型转化异常
存在条件：继承关系，方法需要重写，父类引用指向子类对象 Father f1=new Son();
无法重写：
static 方法，属于类，不属于实例
final 常量
private方法不能重写
instanceof和类型转换
instance可以判断是否有父子关系；
Person person = new Student(); 后面是比较的类型，而前面展开来说是person类型的student对象，所以与Teacher无关系 System.out.println(person instanceof Student); True System.out.println(person instanceof Person); True System.out.println(person instanceof Object); True System.out.println(person instanceof Teacher); False //System.out.println(person instanceof String); person与string没有一点关系，无法比较
//学长理解：instance左边是对象右边是要比较的类，对象属于右边类或者它的子类时是true 形式上：对象 instanceof 类
类型转换
低转高不需要强制转换,但是子类转换为父类可能会失去一些自己本来的方法,所以如果以后要低转高，最好在实例化时就用高
Student student = new Student;
Person person = student;
Person obj = new Student( );
目前无法调用子类obj（Student）的方法，需要将obj这个对象转换为Student类型
转换方法： Student student = (Student) obj;
此时在输入student.go( );就相当于调用了obj对象所在的Student类中的go方法
或者直接 ( ( Student ) obj ).go;
static关键字详解
静态变量
private static int age;//静态变量
private double score;//非静态变量
A a = new A();
System.out.println(a.score);
System.out.println(a.age);
System.out.println(A.age);//类变量
静态变量可以使用类变量的形式，所以一般静态变量都采用类变量形式，方便确实他是静态变量
静态变量在多线程中会用到
静态方法
非静态要先new后调用，非静态方法可以调用静态方法
静态方法在本类中可以直接go( );调用，或者 类名 . go( );
静态方法只能调用静态方法（静态方法与类一起先加载出来，而此时非静态变量还没有加载出来，所以不能调用）
静态代码块
代码块：在程序中直接加入{ }，并在其中写代码叫做匿名代码块。心得对象一创建，会先走匿名代码块（有多少个对象就一共会执行多少次），再走构造器
静态代码块：static{ }类加载时就执行，且永久只执行一次（根据这些特性，常用来赋初始值）
静态导入包
正常使用生成随机数函数，每次都要写Math . random( )
为了减少输入量，可以像C++库（#include math.h）一样将Math所在的包导入到代码开头
import java.lang.Math;
如果想详细的把包里的某个方法调用就需要用到静态导入包
import static java.lang.Math.random;//多加了一个static
抽象类
用abstract修饰可以形成抽象类，抽象方法；就是只有名字没有内容
抽象类的所有方法，继承了他的子类，都必须要去实现他的方法。除非这个子类也是抽象类
抽象类不能实例化，只能靠子类去实现它
抽象类里可以写普通方法，抽象类必须在抽象类里
抽象的目的就是设计架构，比如LOL中英雄各不相同，但是他们的属性类型（ad，ap）和技能组都是共同的。写好架构以后每一个英雄只需要跟着架构进行继承与重写，就能在固定的游戏玩法架构下成就多样性
接口的定义与实现 interface
接口不能写方法，抽象类里还可以写普通方法
接口是为了实现约束和实现分离
接口也不能被实例化
接口就是规范，本质时契约。“如果你是...则必须能...”的思想
接口都需要有实现类，通常用i（i大写）mpl结尾 实现类的关键字是implements
实现了接口的类，就必须要重写接口中的方法 快捷键Ctrl+i或者alt+enter
public class UserSeviceImpl implements UserService，TimeService{}//多继承
声明接口的关键词时interface
接口中的所有定义都是抽象的，方法默认public abstract，属性默认是常量public static final，可以直接写
void add(String name); int AGE=99;
N中内部类
在一个类中再定义一个类，就是内部类
一个java类中可以有多个class但是只能有一个public class
成员内部类
Outer outer = new Outer();//外部实例化 Outer.Inner inner = outer.new Inner();//内部实例化
内部类可以获得外部类的私有属性和私有方法
静态内部类
public static class//生成内部类
由于比外部类先生成所以无法获得外部类的东西
局部内部类
写在方法里面
匿名内部类
没有名字初始化类
new Apple().eat();
异常
Arrayindexoutofbounds数组下标越界异常
ClassCastException类型转化异常
异常可以缩小不能扩大
ERROR一般是程序无法控制的，是灾难性的错误。Exception是可以被程序处理的
异常处理
五个关键字：try catch finally throw throws
try{//try监控区域
代码；
}catch(异常类型 命名){//捕获异常，可以并列着写多个异常，但是要按从小到大排序
打出一些句子来提醒自己；
}finally{//不管程序出不出现异常，都会执行
代码；
}
//这样程序就不会报错。 try catch必须有，finally可选（通过关闭代码可以保证程序会关闭）
Ctrl+Alt+T可以快速生成catch
e(这是个名字).printStackTrace();//可以打印错误的栈信息
抛出异常
throw new 异常类型（）；//主动抛出异常
一般写在方法里，假设这个程序处理不了，可以在方法上抛出异常
throws写在方法后public void test(int a) throws 异常类型；再用try catch接收
自定义异常
继承Expection类，这个类就是自定义异常类了
经验
if（flag==true）{}
if (flag){}
//这两个一样，默认判断为真
JDK7新特性，数字直接可以用下划线分割，且不会被输出
s.equals("Hello");判断字符串s是否为Hello
可以使用
if(){
}else if(){
}else if(){
}else{
}
int a=10;
int b=20;
System.out.println(""+a+b);
//输出结果为1020；
switch如果不写break，则会发生case穿透现象
break会跳出switch，结束循环 而continue能跳过此次循环进入下一个循环、return代表方法结束
do{
代码
}while（布尔表达式）
//能保证至少执行一次
输入100.for会自动生成for(int i=1;i<100;i++）循环100次
Arrays.sort(a); 把数组a排序（升序）
Arrays.toString(a);把a数组打印
Arrays.fill(a, val:0);用0将数组a填充
Arrays.fill(a,fromlndex:2, tolndex:4,. val:0);只填从2到4的位置，左开右闭
alt+enter自动补充代码
输出时"人数为"+num-- +"个"，num--意思是每输出一次num-1
Date startTime = new Date(System.currentTimeMillis( )) 获取当前系统时间
sout(new SimpleDateFormat("HH:mm:ss").format(startTime))输出
使用static去new类，可以保证资源只有一份