1.数据类型
强类型语言：要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用
Java的数据类型分为两大类：基本类型（primitive type），有8大基本类型，此外都是引用类型
引用类型（reference type）
1.1变量和作用域
变量：1.Java是一种强类型语言，每个变量都必须声明其类型
2.Java变量是程序中最基本的存储单元，要素包含变量名，变量类型和作用域
作用域：1.类变量（static），可以不初始化
2.实例变量，从属于对象，需要声明不需要初始化
3.局部变量，必须声明和初始化值（无默认值，必须经过初始化才能使用），只在方法内有效，分配在栈上
1.2常量
常量：初始化后不能再改变的值，不会变动的值。
可以理解为一种特殊的变量，其值被设定后，在程序运行过程不允许被更改。
1.3变量的命名规范
所有变量、方法、类名：见名知意
类成员变量：首字母小写+驼峰原则：lastName
局部变量：首字母小写+驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写+驼峰原则：Man，GoodMan
方法名：首字母小写+驼峰原则：run()，fastRun()
2 访问控制修饰符
Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。
default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
2.1 默认访问修饰符-不使用任何关键字
使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。
2.2 访问控制和继承
请注意以下方法继承的规则：
父类中声明为 public 的方法在子类中也必须为 public。
父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
父类中声明为 private 的方法，不能够被子类继承。
2.3 final 修饰符
final 变量：
final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。
final 修饰符通常和 static 修饰符一起使用来创建类常量。
final 方法
父类中的 final 方法可以被子类继承，但是不能被子类重写。
final 类
final 类不能被继承，没有类能够继承 final 类的任何特性。
2.4 abstract 修饰符
抽象类：
抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
2.5 转义序列
4.流程控制
4.1 选择结构：
if单选择结构 if( )
if双选择结构 if( ){ }else{ }
if多选择结构 if( ){ }else if{ }else{}
嵌套的if结构 if( ){ if( ) }
4.2 switch多选择结构
switch case：语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。
4.3 循环结构
4.3.1 while循环
4.3.2 do...while循环
4.3.3 for循环
4.3.4 增强for循环（可以用来遍历集合或者数组）
增强for不能完全替换普通for,原因有两：
1,没有索引
2,不能使用add也不能使用remove
增强for遍历数组如下：
增强for遍历集合
4.3.5 循环结构中常用的关键字
break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。break 跳出最里层的循环，并且继续执行该循环下面的语句。（跳出循环）
continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。（跳出本次循环，继续下次）
4.4 常见的类
Character 类用于对单个字符进行操作。Character 类在对象中包装一个基本类型 char 的值
String 类
5.Java方法
5.1 方法的定义
解释说明 修饰符：可选
返回值类型：方法可能会返回值。如果方法无返回值，则returnValueType为关键字void。
参数类型：像一个占位符。参数列表是指方法的参数类型、顺序和参数个数。参数是可选的，方法可以不包含任何参数。
注：定义时为形参，实际调用时为实参
5.2 方法的调用
调用方法：对象名.方法名（实参列表）
Java支持两种调用方法：
1.当方法返回一个值的时候，方法调用通常被当成一个值。
2.方法返回值是void时，方法的调用是一条语句。
注：调用其他类的方法，除非是static静态方法（静态方法属于类，非静态方法属于对象），不然必须实例化这个类。一个方法加上static唯一目的：为了能直接调用（类名.静态方法名（））
5.3 方法的重载
定义：重载是在一个类中，有相同的方法名，参数列表不同的方法。
方法重载的规则：方法名必须相同，参数列表必须不同（个数，参数类型或排序不同），返回类型可以相同也可以不同
注：仅仅返回类型不同不足以成为方法的重载
可变参数：Jdk1.5开始，Java支持传递同类型的可变参数给一个方法。一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。
1.可变参数：定义方法时参数个数是可变的
2.可变参数的格式：
修饰符 返回值类型 方法名(参数类型... 参数名){
方法体
return 返回值 ；}
3.调用时可以给0参数 1个参数或者多个参数
4.可变参数的本质是一个数组
5.可以接受数组
小结：如果方法的参数个数是可变，可以使用可变参数，方法只要定义一个
5.4 递归
递归结构：
递归头：什么时候不调用自身方法，没有头 将陷入死循环。
递归体：什么时候需要调用自身方法。
6.Java数组
Java语言使用new操作符来创建数组，数组的元素通过索引访问的
dataType[] arrayRefVar = new dataType[arraySize]; //int[] nums=new int[10]
6.1数组的三种初始化
静态初始化
int[ ] a={1,2,3}
Man[ ] mans={new Man(1,1),new Man(2,2)}
动态初始化
int [ ] a=new int[2]; a[0]=1;a[1]=2;
默认初始化：数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
6.2数组的基本特点
1.数组是相同数据类型（数据类型可以为任意类型）的有序集合
2.数组长度确定，不可变。如果越界，则报：ArrayIndexOutofBounds
3.数组也是对象，数组元素相当于成员变量。（Java中对象在堆中，因此数组无论保存原始类型还是其他对象类型，数组本身是在堆中的）
数组使用：
For-Each循环
数组可以作方法入参
数组作返回值
多维数组
多维数组可以看成数组的数组，比如二维数组就是一个特殊的数组，其每一个元素都是一个一维数组。
7.Arrays类
数组的工具类java.util.Arrays
作用：数组本身没有方法可以供我们使用，API提供了一个工具类Arrays供我们使用。Array类中的方法都是static修饰的静态方法，使用时直接用类名进行调用，可以不用对想调用。
常用功能：
赋值：给数组赋值fill方法。
排序：sort方法，升序。
比较数组：equals方法比较数组中元素值是否相等。
查找数据元素：binarySearch对排序好的数组进行二分查找法操作。
8.面向对象
从代码运行角度考虑是先有类后有对象。类是对象的模板。
8.1创建与初始化对象
使用new来创建对象，创建的时候，除了分配内存之外，还会给创建好的对象进行默认的初始化，以及对类中构造器的调用。
类中的构造器也被称为构造方法，创建对象时必须要调用。有以下特点：
1.必须和类的名字相同
2.没有返回类型，也不能写void
3.一个类即使什么都不写，也会存在一个默认的构造方法
8.2内存分析
//定义一个宠物类
public class Pet {
public String name; //默认 null
public int age; //默认 0
//无参构造
public void shout(){
System.out.println("叫了一声");
}
}
//应用类，创建调用对象
public class Application {
public static void main(String[] args) {
Pet dog = new Pet();
dog.name = "旺财";
dog.age = 3;
dog.shout();}}
9.封装
我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据细节由自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装（数据的隐藏）：通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，称为信息隐藏；
作用：1.提高程序的安全性，保护数据 2.隐藏代码的实现细节 3.统一接口 4.系统可维护性增加了
引用类型的使用有三个步骤：
1.导包
2.创建对象
数据类型 对象名=new 数据类型();
3.调用方法完成功能
对象名.成员方法名();
10.继承
继承的特点：
1.extends的意思是”扩展“。子类是父类的扩展，使用关键字extends来表示。
2.Java中只有单继承，没有多继承，一个类只能继承一个父类
3.继承是类与类之间的一种关系，比如依赖、组合、聚合等。
4.继承关系的两个类，一个为子类（派生类），一个为父类
5.子类和父类之间，从意义上讲应该是“is a”的关系。
6.子类继承了父类，就会拥有父类的全部方法，而private私有属性及方法无法继承。
7.在Java中，所有类，都默认直接或间接继承Object类 (Ctrl+H 可以查看类关系)
8.被final修饰的类，无法被继承（断子绝孙）。
10.1 super&this
super和this的区别：super代表父类对象的引用，只能在继承条件下使用；this调用自身对下，没有继承也可以使用
1.super()调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或构造方法中
3.**super()和this()**不能同时调用构造方法，因为this也必须写在第一行
10.2方法的重写
重写：子类的方法必须与父类方法一致，方法体不同。重写是方法的重写与属性无关。重写方法只与非静态方法有关，与静态方法无关（静态方法不能被重写）
注：1.静态方法属于类，非静态方法属于对象
2.方法名，参数列表必须相同
3.修饰符可以扩大，不能缩小（public>protect>private）
4.抛出异常范围可以缩小，不能扩大
5.被**static（属于类，不属于实例），final（常量方法），private（私有）修饰的方法不能重写
public class B {
public static void test(){ //静态方法
System.out.println("B==>test()"); }}
public class A extends B{ //继承 public static void test(){ System.out.println("A==>test()"); }}
public class Application {
public static void main(String[] args) {
//方法的调用之和左边定义的类型有关
A a = new A();
a.test(); //打印 A==>test()
//父类的引用指向了子类，但静态方法没有被重写
B b = new A();
b.test(); //打印 B==>test() }}
11.多态
定义：同一个方法可以根据发送对象的不同而采用不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用可以有很多
多态存在条件：
1.有继承关系
2.子类重写父类方法
3.父类引用指向子类对象(对象能执行哪些方法，主要看对象左边的类型，和右边关系不大，但执行方法的内容取决于右边即子类重写了父类的方法执行结果是子类方法处理的结果)
注意点：1.多态是方法的多态，没有属性的多态
2.父类和子类，有联系类型转换异常：ClassCastException
3.存在条件：继承关系，方法需要重写，父类引用执行子类对象
11.1 instanceof和类型转换
instanceof 引用类型比较，判断一个对象是什么类型
类型转换：
1.父类引用指向子类对象
2.把子类转换为父类，向上转型，会丢失自己原来的一些方法
3.吧父类转换为子类，向下转型，强制转换，才可调用子类方法
4.方便方法的调用，减少重复的代码，简洁
11.2 Static
静态变量可以直接用类名访问，也称类变量
静态变量（或方法）对于类，所有对下（实例）所共享
静态区代码加载类时一起被初始化，最早执行且只执行一次（第一次new）
11.3 abstract
1.abstract修饰的类就是抽象类，修饰的方法就是抽象方法
2.抽象类中可以没有抽象方法，但有抽象方法的类一定要声明为抽象类
3.抽象类不能使用new来创建对象，它是用来让子类继承的
4.抽象方法只有方法的声明，没有实现，让其子类实现
用abstract修饰，没有{ }
5.子类继承抽象类，必须实现抽象类的所有方法，否则该子类也要声明为抽象类
12.接口（interface）
区别：
普通类只有具体实现
抽象类具体的实现和规范（抽象方法）都有
接口只有规范，没有方法实现，专业的约束！约束与实现分离：面向接口编程
注：接口的本质是约束，就像人间法律一样，制定好大家都遵守
接口可以继承接口 extends，但接口不能直接创建对象
调用实现类方法，执行的就是实现类中的代码
一个接口可以有多个实现类
注意点：
1.接口没有构造方法，不能被实例化
2.实现类必须重写接口中的方法
3.实现类（implements）可以实现多个接口
原文链接：https://blog.csdn.net/fllow_wind/article/details/116174854
13.内部类
内部类就是在一个类的内部再定义一个类，比如A类中定义了一个B类，那么B就是A的内部类，而A相对B来说就是外部类
成员内部类：可以操作外部类的私有属性及方法
静态内部类：static修饰，不能访问外部类私有属性
局部内部类：外部类的方法里定义的类
匿名内部类：没有名字初始化类
14.异常
定义：软件程序在运行过程中，经常可能遇到异常问题，异常英文(Exception)，意思是例外，这些例外情况需要我们写程序做出合理的处理，而不至于让程序崩溃。异常发生在程序运行期间，它影响了正常的执行流程。
简单分类
1.检查型异常：最具代表性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如用户要打开一个不存在的文件时引发的异常，这些异常在编译时不能被简单地忽略。
2.运行时异常：是可能被程序员避免的异常，与检查性异常相反，运行时异常可以在编译时忽略。
3.错误Error：错误不是异常，而是脱离程序员控制的问题。错误在代码经常被忽略。例如当栈溢出，一个异常就发生了，它们在编译也检查不到。
小结:编译时异常,运行时异常，如果继承RuntimeException就是运行时异常,否则编译时异常
编译时异常，调用方法有红线。运行时异常，调用方法没有红线
异常产生的流程：
14.1 异常处理机制
抛出异常，捕获异常，异常处理关键字：try、catch、finally、throw、throws
14.1.1 使用throw手动抛出异常
1.异常可以抛出（甩锅），也可以处理
2.throw是java的一个关键字
3.手动抛出异常
throw new 异常类(异常的提示信息)；
4.throw 只能方法内使用
14.1.2 使用throws声明异常
1.如果一个方法运行时才抛出异常，那么太晚了
2.throws目的是在调用时提示异常（红色线）
3:格式
修饰符 返回值类型 方法名(参数) throws 异常名1,异常名2{
方法体
return返回值;}
4:方法内throw new 编译时异常(); 那么方法上必须加throws编译时异常;
此时目的提示开发者(给一个红线),开发者可以抛也可以 try...catch
5:方法内 throw new 运行时异常(); 那么方法上可选择加 throws 运行时异常.
此时还是不能提示开发者(不给一个红线)
小结:编译时异常可以给开发者提示,而运行时编译不能起到这个作用
throw只能写在方法内,而throws 只能写在方法上
14.1.3 try...catch捕获异常
1.try...catch语句可以让开发者处理异常 包含运行时异常,编译时异常
2:格式
try{
//1:可能抛出异常
}catch(异常类名 变量名){
//2:处理异常的代码
}
//3:后续代码
3:执行流程:
先执行try的代码块
没有异常产生: 1:->3:
有异常产生被捕获1: ->2: ->3:
有异常产生但是没有被捕获1:
//小结：不使用throws 抛异常，那么使用try..catch
为了捕获到异常 异常类名写抛出来的类型
try...catch...finally
14.1.4 自定义异常
1:自定义异常,继承异常相关的类
2:不会继承Throwable
3:运行时异常 extends RuntimeException子类
4:编译时异常 不是RuntimeException子类
5:一般继承:Exception
————————————————
原文链接：https://blog.csdn.net/fllow_wind/article/details/116174854
