JAVA基础
注释
- IDEA中Setings选项Editor里Java选项Comments选项有三个选项能调节注释
- 注释不会被执行，只是给人看的。
- 单行注释
//注释内容
单行注释
注释一行的内容
多行注释
/*
注释
*/
可以注释一段文字
JavaDoc文档注释
/** */
/**
*@Description
*@Author
*/
写代码一定要注意规范
标识符
关键字
class、static、
标识符注意点
- 所有的标识符都应该以字母（A-Z或者a-z），美元符（$），或者下划线(_)开始
- 首字符之后可以是字母，美元符，下划线或数字的任何字符组合
- 不能使用关键字作为变量名或方法名
- 标识符是大小写敏感的
- 合法标识符举例：age、$salary_value、__1_value
- 非法标识符：123avc、-salary、#abc
public static main(String[] args){
String 王者荣耀 = "最强王者"
System.out.println(王者荣耀);
}- 可以使用中文命名，但是不建议使用，不建议使用拼音
- 建议遵从阿里开发规范手册
数据类型
Java是强类型语言：要求变量的使用要求严格符合规定，所有变量都必须先定义后才能使用（安全性高，速度慢）
弱类型语言：要求变量的使用要求低（速度快，安全性低）
基本类型
- 数值类型：
- 整数类型：
- byte：占1个字节（1个字节=8位；2的8次方）
- short：占2个字节
- int：占4个字节
- long：占8个字节（该类型后面要加L）
- 浮点类型：
- float：占4个字节（后面要加F）
- double：占8个字节
- 字符类型：
char：占2个字节
- boollean类型：占1位其值只有true和false两个
整数拓展：
进制： 二进制0b 十进制 八进制0 十六进制0x
浮点数拓展：银行业务怎么表示？钱
BigDecimal 数学工具类
float 有限 离散 舍入误差 大约 接近但不等于
float f = 0.1f;//0.1
double d = 1.0/10;//0.1
System.out.println(f==d);//false
float d1 = 213213131131f;
float d2 = d1+1;
System.out.println(d1==d2);//true最好完全避免使用浮点数进行比较
字符拓展：
//所有的字符本质还是数字
//编码 Unicode 2 字节 0–>65536 = 2的16次方
char c3 = ‘\u0061’;输出以后是a（0开头是16进制）\u代表转义
转义字符：
\t 空格(制表符
\n 换行
布尔值扩展：
boollean flag = true;
if(flag == true){}
if(flag){}//使用这种，代码要精简易读
引用类型
类
接口
数组
类型转换
低------------------------------------------->>高
byte 、short、int、long、float、double
//强制类型转换（高到低）：（类型）变量名
//自动类型转换（低到高）：
注意点
- 不能对布尔值进行转换
- 不能把对象类型转换为不相干的类型
- 再把高容量转换到低容量是，强制类型转换
- 转换的时候可能存在内存溢出，或者精度问题！
- 操作比较大的数的时候注意溢出问题//JDK7的新特性：数字之前可以用下划线分割
int money = 10_0000_0000;
int years = 20;
long total = money*((long)years);//先把其中一个数转换为Long
变量、常量、作用域：
变量
定义时尽量一个变量一行，以英文的分号结尾；
变量的命名规范：
- 所有的变量、方法、类名：见名知意
- 类成员变量：首字母小写和驼峰原则：monthSalary 除了第
一个单词外，后面的单词首字母大写 lastName - 局部变量：首字母小写和驼峰原则
- 常量：大写字母和下划线： MAX_SUM；
- 类名：首字母大写和驼峰原则：Man，GoodMan
- 方法名：首字母小写和驼峰原则：run().runRun();
常量
定义在类里方法外
修饰符 final（修饰符不存在先后顺序）来定义
作用域
类变量
定义在类里方法外
用static关键字修饰
实例变量
- 写在类里面，方法的外面。
- 如果不自行初始化，会自行定义为默认值。 0 0.0
- 布尔值默认为false
- 除了基本类型，其余的都是null
局部变量
- 必须声明和初始化值。
- 写在方法体里面
基本运算符
优先级（）最高
- 算术运算符：+，+，*，、%，++，–
- 合运算时会提升为最大的数据类型(byte与short与char运算会提升为int)
- 赋值运算符：=
- 关系运算符：>,<,>=,<=,==,!=,instanceof
返回结果是布尔值 - 逻辑运算符：&&,||,!
- 与，或，非
- 位运算符：&,|,^,~,>>,<<,>>>
<< >> - 条件运算符?：
- 扩展赋值运算符：+=,-=,*=,/=
三元运算符
- 字符串连接符 +, String （当出现String时，字符串后面的元素都会转化为字符串再操作。字符串之前的不予理会）
x ? y : z
如果x==true，则结果为y，否则结果为z
JavaDoc生成文档
流程控制
Scanner对象
public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("使用next方式接收：");
if (scanner.hasNext()){
String str = scanner.next();//使用next方式接收
System.out.println("输入的内容为："+str); }
scanner.close();
}
@Test
public void demo02(){
Scanner scanner = new Scanner(System.in);
System.out.println("使用nextLine接收：");
if (scanner.hasNextLine()){
String str = scanner.nextLine(); System.out.println("你输入的内容是："+str); }
scanner.close();
}- next()
- 一定要读取到有效字符后才可以结束输入。
- 对输入有效字符前遇到的空白，next()方法会自动将其去掉
- 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
- next()不能得到带有空格的字符串。
- nextLine():
- 以Enter为结束符，也就是说 nextLine()方法返回的是输入回车之前的所有字符。
- 可以获得空白。
顺序结构
任何一个算法都离不开的一种基本算法结构
Java方法
- 语句的集合，在一起执行一个功能
- 方法包含于类中或对象中
- 方法在程序中被创建，在其他地方被引用
- 设计方法的原则：方法的本意是功能快，就是实现某个功能的语句块的集合。我们设计方法的时候最好保持方法的原子性，指一个方法只完成一个功能，有利于后期的扩展
- 命名遵守seeSaa驼峰原则
- 是一段用来完成特定功能的代码片段
方法的定义及调用
- 方法包含一个方法头和一个方法体
- 修饰符：可选；告诉编译器如何调用该方法。定义了该方法的访问类型
- 返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType是关键字void。
- 方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
- 参数类型：参数像是一个占位符。当方法被调用是，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、书序和参数的个数。参数是可选的，方法可以不包含任何参数。
- 形式参数：在方法被调用时用于接收外界输入的数据。
- 实参：调用方法时实际传给方法的数据。
- 方法体：方法体包含具体的语句，定义该方法的功能
修饰符 返回值类型 方法名（参数类型 参数名 ）{
…
方法体
…
return 返回值；
}
方法的重载
- 在一个类中，有相同的函数名称，但形参不同的函数
- 重载的规则：
- 方法名必须相同
- 参数列表必须不同(个数不同或类型不同或参数排列顺序不同等)。
- 方法的返回类型可以相同也可以不同
- 仅仅返回类型不同不足以成为方法的重载
- 实现理论：
- 方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。
可变参数
不定项参数
- 在方法声明中，在指定参数类型后加一个省略号（…）。
- 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
递归
- A方法调用A方法！自己调用自己
- 利用递归可以用简单的程序来解决一些复杂的问题。他通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出阶梯过程所需要的多次重复计算，减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
- 递归结构包括两个部分：
- 递归头：什么时候不调用自身方法。如果没有头，会进入死循环。
- 递归体：什么时候需要调用自身方法。
数组
- 数组的长度是确定的，大小不可改变
- 元素必须是相同类型
- 元素可以是任何数据类型，包括基本类型和引用类型
- 数组变量属于引用类型，因此可以看成是对象，每个元素相当于对象的成员变量，数组对象本身是在堆中的。
数组的声明和创建
int[] nums;//定义 1
nums = new int[10];//里面放了10个元素 2- Java预压使用new操作符来创建数组，语法如下：
dataType[] arrayRefVar = new dataType[arraySize];
数据类型[] 数组名字 = new 数据类型[数组长度];
三种初始化和内存分析
1数组定义时在栈中压入数组名
2创建数组时使用new，在堆中开辟一片空间并将空间分为数组长度份数的空间存放对象.
3给数组元素赋值才能让堆中的对象有值
- 静态初始化：创建+赋值
int[] a = {1,2,3,4};//一旦定义就不能改变了 - 动态初始化:包含默认初始化
int[] b = new int[10]; - b[0] = 10;
- 数组的默认初始化
数组是引用类型，一经分配空间就会将其分配的元素按照实例变量同样的方式进行隐式初始化。
数组边界
- 数组是相同数据类型（数据类型可以为任意类型）的有序集合
- 数组也是对象。数组元素相当于对象的成员变量
- 数组长度是确定的，不可变的。如果月结，则报：ArrayIndexOutOfBoundsException
数组的使用
- for each遍历
数组名.for - 数组作为参数在方法中入参
- 数组作为返回值
多维数组
定义：
int[][] [] [] 数组名 = {{1,2},{3,4},{5,6}}
面向对象编程 OOP
什么是面向对象
面向对象编程
本质：以类的方式组织代码，以对象的组织（封装）数据
抽象：编程思想！持续的学习，茅塞顿开！多实践，多测试大脑中的想法！多实现脑中的想法
三大特性：封装，继承，多态
从认识论角度考虑是现有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
从代码运行角度考虑是现有类后有对象。类是对象的模板。
- 面向过程思想（线性）
- 步骤清晰简单，第一步做什么，第二部做什么…
- 面对过程适合额处理一些简单的问题
- 面向对象思想
- 物以类聚，分类的思维模式，思考问题会首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
- 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是具体到微观操作，仍然需要面向过程的思路去处理。
方法的调用
值传递：因为指向方法中的值，没有返回值的话，不会改变原程序的属性。
引用传递：因为指向方法中的对象，所以能改变对象中定义的属性。
类与对象的创建
构造器：
1.和类名相同
2.没有返回值
作用：
1.new 本质在调用构造方法
2.初始化对象的值
注意点：
1.定义有残构造之后，如果想使用无参构造，显示的定义一个无参的构造。
- 类与对象
类是一个模板：抽象，对象是一个具体的实例 - 方法
定义、调用！ - 对应的引用
引用类型：基本类型（8）
对象是通过引用来操作的：栈---->堆 - 属性：字段Field 成员变量
默认初始化：
数字：0 0.0
char: u000
boolean: false
引用: null
修饰符 属性类型 属性名 = 属性值！ - 对象的创建和使用
- 必须使用new 关键字创造对象，构造器 Person dyq = new Person();
- 对象的属性 dyq.name
- 对象的方法 dyq.study()
- 类：
- 静态的属性 属性
- 动态的行为 方法
封装
- 提高程序的安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 系统可维护增加了
- 该露的露，改藏的藏
- 程序设计要求高内聚，低耦合；高内聚是类的内部数据细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
- 封装(数据的隐藏)
- 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏
- 属性私有，get/set。
继承
- 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
- extends的意思是扩展。子类是父类的扩展。
- JAVA中类只有单继承，没有多继承！
- 继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等。
- 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
- 子类和父类之间，从意义上讲应该具有"大象is a 动物"的关系
- Object
- super
调用父类的方法或属性的关键字
调用父类的构造器必须放在代码第一行
super和this不能同时调用构造方法
super必须只能出现在子类的方法或者构造器中！
- 与this的比较
- 代表的对象不同：
this：本身调用者这个对象
super:代表父类对象的应用 - 前提
this：没有继承也可以使用
super：只能在继承条件才可以使用 - 构造方法
this()；本类的构造
super（）：父类的构造
- 方法重写
方法的重写
静态方法时：方法的调用只和创建实例对象的左边有关，即与定义的数据类型有关
重写至于非静态有关，静态方法不算重写。
- 需要有继承关系，子类重写父类的方法；
- 方法名必须相同
- 参数列表必须相同
- 修饰符：范围可以扩大但是不能缩小：
- 抛出的异常：范围可以被缩小但不能扩大：
- 子类的方法和父类必需一致：方法体不同！
- 为什么要重写：
- 父类的功能，子类不一定需要，或者不一定满足！
多态
注意事项
- 多态是方法的多态，属性没有多态
- 父类和子类有联系 类型转换异常！ ClassCastExeception
- 存在条件：继承关系，方法需要重写，父类引用指向子类对象father f1 = new son();
不能重写的方法：
- static 方法属于类不属于实例
- final 修饰的 在常量池里；
- private 修饰的
- 即同一方法可以根据发送对象的不同而采用多种不同的行为方式
- 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类，有关系的类）
- 多态存在的条件：
- 有继承关系
- 子类重写父类的方法
- 父类引用指向子类对象
- 多态是方法的多态，属性没有多态
- instanceof （类型转换）引用类型，判断一个对象是什么类型
类型转换：
- 父类引用指向了子类的对象
- 把子类转换为父类，向下转型
- 把父类转换为子类向下转型 强制转换
- 方便方法的调用，减少重复的代码
- 子类转换为父类时，可能丢失自己本来的一些方法！
抽象类
继承抽象类的子类要实现抽象类的所有方法，除非子类也是抽象类；
- 不能 通过 new 来创建实例对象，只能靠子类来继承实现它：约束！
- 抽象类中可以写普通方法
- 抽象方法必须在抽象类中
抽象类存在构造器吗？
存在构造器
抽象类存在的意义：提高开发效率（可扩展性高）
接口
- 普通类：只有具体实现
- 抽象类：具体实现和规范（抽象方法）都有！
- 接口：只有规范！自己无法写方法专业的约束！约束和实现分离：面向接口编程
- 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。
- 接口的本质是契约，就像我们人间的法律一样，制定好后大家都遵守
- OO的精髓，是对对象的抽象，最能体现这一点的接口就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如java，c++，c#…），就是因为设计模式所研究的，实际上就是如何合理的去抽象。
- 可看23种实现方式
作用:
- 约束
- 定义一些方法，让不同的人实现
- public abstract
- publicstaticfinal
- 接口不能被实例化，接口种没有构造方法
- implements可以实现多个接口
- 必须要重写接口种的方法。
内部类
异常
简单分类：
- 要理解Java异常是如何工作的需要掌握以下三种异常：
- 检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
- 运行时异常：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
- 错误：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译时是检查不到的。
Error:
- Error类对象由Java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。
- Java虚拟机运行错误，当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。
- 还有发生在虚拟机试图执行应用时，如类定义错误（NoClassDefFoundError）、链接错误（LinkageError）。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。
Exception
- 在Exception分治中有一个重要的子类RuntimeException（运行时异常）
- ArrayIndexOutOfBoundsException（数组下标越界）
- NullPointerException（空指针异常）
- ArithmeticException（算术异常）
- MissingResourceException（丢失资源）
- ClassNotFoundException（找不到类）等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。
- 这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生；
- Error和Exception的区别：Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM）一般会选择终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。
finally一般用于善后工作如IO流的关闭。
catch（想要捕获的异常）
假设要捕获多个异常：从小到大进行；
选中需要捕获异常的代码 ctrl+alt+t选择try/catch
方法中抛出用throw方法体上用throws；
经验总结：
- 处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理
- 在多重catch块后面，可以加上一个catch（Exceptin）来处理可能会被遗漏的异常
- 对于不确定的代码，也可以加上try-catch，处理潜在的异常
- 尽量去处理异常，要根据不同的业务需求和异常类型去决定
- 尽量添加finally语句块去释放占用的资源
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
