Java第一阶段
一、语言基础
<>Java开发环境：
编译期：.java的源文件经过编译，生成.class字节码文件
运行期：.class的字节码文件由JVM加载并运行，生成（
0和1）；
1. JVM
Java虚拟机，加载.class文件并运行.class文件
2. JRE
Java运行环境，除了包含JVM外，还包含了运行Java程序所必须的环境
JRE = JVM +系统类库小零件
运行Java程序的最小环境为JRE
3. JDK
Java开发工具包，除了包含JRE外，还包含开发java程序所必须的命令工具
JDK=JRE+编译、运行等命令工具
开发程序的最小环境为JDK
<>IDEA
JetBrains公司的，分为社区版（免费）和终极版（收费）
<>
开发步骤：
1.新建项目
2.新建包：建议“小驼峰命名法”
3.新建类：建议“大驼峰命名法”
<>
注释符：注释信息，计算机不运行
1.“//”单行注释
2.“/* */”多行注释
3.“/** */”文档注释
<>变量：代词，存数的，指代里面的数字
1.声明变量，如int a；
2.初始化变量，即第一次赋值，如int a = 5；
3.使用变量，就是使用变量指代的数，如，a = 10;
4.使用变量前，必须声明并初始化
<>命名：（标识符）
1.只能包含数字，字母，下划线和$符号，并且，不能以数字开头
2.严格区分大小写
3.不能使用关键字
4.允许中文，但不建议，英文的见名知意
<>八大基本数据类型：
1. byte,字节型，专门存储整数，占1个字节，范围是-128~127；
2. short短整型，专门存储整数，占2个字节，范围是-32768~32767；
3. int整型，专门存储整数，占4个字节，范围是-2的31次幂~2的31次幂减1
4. long长整型，专门存储整数，占8个字节，范围是-3的63次幂到3的63次幂减1
5. float单精度浮点型，专门存储小数，占4个字节
6. double双精度浮点数，专门存储小数，占8个字节
7. Boolean布尔型，存储true和false,占1个字节
8. Char字符型，采用unicode字符集编码格式，又叫万国码，存储单一字符，每个字符占
2个字节，范围是0~65535
<>类型间的转换：
1.自动类型转行
小型到大型
2.强制类型转换
大型到小型
语法：（要转成的数据类型）变量
注意要点：强转可能会发生溢出或丢失精度
3.两点规则：
1） 整数直接量可以直接赋值给byte,short,char，但是不能超过其类型的范围；
2）byte, short,char参与运算时，系统一律将其转换为int类型再运算
<>运算符：
1.算数运算符
“+”
“-”
“*”
“/”
“%”
“++”
“--”
%取余或取模，余数为0为整数
++/--自增1或子减1，放在变量名前后所得值不同，例如，++a和a++,单独使用时值相同，
被使用时，值不同，a++,先取值后增1，++a,先增1，后取值
2.关系运算符
“>” “<” “>=” “<=” “==” “！=”
关系运算的结果为boolean类型，结果返回真为true,假为false
3.逻辑运算符
“&&”“||”“！”
逻辑运算的结果为boolean型
逻辑与，见false为false
逻辑或，见true则true
逻辑非，结果值取反
4.赋值
“=”“+=”“
-=”“*=”“
/=”“%=”
简单赋值运算符：=
扩展赋值运算符，如“+=”a+=b为a=a+b,其余同理
注意要点：扩展赋值运算符自带强转功能
Short s = 10;
s += 10;(编译正确)
s = s+10(编译错误)，应为s = (short)(s+10)
5.字符串连接
“+”
若两遍都是数字，直接相加
若是字符串格式，则做字符串连接，任何形式与字符串连接，都会变成字符串类型，被称为
同化作用
<>条件/三目运算
语法：Boolean?数目1：数目2判断条件，为真取数目1，为假取数目2
<>分支结构
1.单条分支结构：(如果为真，输出语句块)
If(条件1 ){
语句块1
}
2.两条分支：（如果为真，输出语句块1，如果为假，输出语句块2）
If(boolean条件1){
语句块1
}else{
语句块2
}
3.多条分支
1）If…elseif结构
if(条件1 ){
语句块1
}else if (条件2){
语句块2
}else if(条件3){
语句块3
}else{
语句块4
}
2）switch case结构
Switch（command）{
case 1:
Syestem.out.println();
break;
case 2:
Syestem.out.println();
break;
case 3:
Syestem.out.println();
break;
default:
注：default可写在分支条件任意位置或者不写；break用于跳出循环，不写的话继续执行
要点：switch作用于的数据类型，byte , short, int, char, String,枚举类型
Switch case的优点：效率高，结构清晰；缺点是只能作用于整型，如果确定是整型，直接
用switch case结构
<>循环结构（三要素：循环变量初始化，循环控制条件，循环变量的改变）
1）while循环，先循环，后判断，可能一次也不执行
初始化；
while(Boolean条件) {
循环体
循环变量的改变；
}
2）do while循环，先执行后判断，至少执行一次
do{
循环体
}while(循环控制条件)
3）for循环
for(循环变量初始化；循环控制条件；循环变量的改变){
循环体；
}
要点：如果已明确循环的次数，直接选for循环，如果循环第一要素与第三要素相同直接选
do while循环，其次选while循环
break跳出循环；continue跳出剩余语句进入下次循环
接收器：
Import java.util.Scanner;
Scanner scan = new Scanner(System.in);
Int a = scan.nextInt();
随机数：
Import java.util.Random;
Random rand = new Random;
Int b = rand.nextInt( );注：改值生成的随机数是0.00到0.99..
<>嵌套循环：
1） 多行多列时使用，外环控制行，内行控制列
2） 外环走一次，内环走所有次
3） 嵌套次数越少越好
4）break只能跳出当前一层循环
<>数组
1.是一种引用数据类型
2.相同数据类型元素的集合
三种定义方式：
Int [] a = new int [5];
Int [] a1 = new int []{
};
Int [] a2 = {1,2,3 };3.给数组的元素做初始化
Int [] a = new int [3];
a [0] = 1;
a [1] = 2;
a [2]=3;
4.数组的访问
访问的是数组的元素，通过 数组名.length访问数组长度，即数组的元素个数。
数组第一个元素从下标0开始访问，最大到数组的长度-1，即，数组名.length-1
5.遍历/迭代
for循环，从头至尾，将所有数据全部输出一遍
6.数组的复制
1）System.arraycopy(a,1,b,2,4);更灵活
解析：复制源a数组，从a的下标1开始4个元素到b数组，下标为2的位置复制
注：容易发生数组下标越界异常
2）int [] b = Arrays.copyOf( a,6);常常扩容缩容时使用
解析：将源a数组，从下标为0开始，6个元素复制给数组b
7.数组的排序
Arrays.sort(arr);升序排列
<>方法
1.又叫函数，过程
2.封装一段特定的业务逻辑功能
3.尽可能独立，一个方法只做一件事
4.方法可以被反复多次被调用
5.减少代码量，有利于代码复用，有利于代码维护
定义方法的5要素：
修饰词 返回值类型 方法名 参数列表 方法体（具体的功能实现）
要点：定义一个方法明确两个点：
1） 返回值类型
2） 有无参数
调用方法
1） 无返回值： 方法名（有参传参）
2） 有返回值： 数据类型 变量 方法名（有参传参）
6. Return
有返回值时，
return值;结束方法执行，将结果返回给调用方
无返回值时，
return ;结束方法执行
二、面向对象
类：现实生活由很多很多对象组成，基于对象抽出了类
对象：软件中真实存在的单个个体/东西
关系：类是对象的模子，对象是类的具体实现
特点：类中可以包含对象的属性和特征，即成员变量
类中可以包含对象的行为功能和动作，即方法
如何创建类
如何创建对象
如何访问成员
<>方法的重载（
overload/overloading）
只看方法的签名：即方法名和参数列表，与其他无关
方法重载，方法名必须相同，参数列表不同
编译器在编译时，会根据方法的签名自动绑定方法，更加方便用户的访问
<>构造方法
1）定义：又叫构造器，构建器
2）作用：复用给成员变量赋初值代码
3）与类同名，没有返回值类型，连void都没有
4）在创建（
new）对象时自动调用
5）如果自己不写构造方法，则编译器会默认提供一个无参的构造方法，若自己写了构造方
法，则默认不再提供
6）构造方法可以被重载
<>this指代当前对象，哪个对象调用方法，就指哪个对象
只能用在方法中，方法中访问成员变量之前默认有个this
This的用法：
This.成员变量名-------访问成员变量
注：成员变量与局部变量同名时，若想访问成员变量，this不能省略
This.方法（），调用方法
This( ).调用构造方法
Null表示空，没有指向任何对象
如果引用的值为null,则该引用不能进行任何点操作，否则会发生空指针异常
<>引用类型数组：
1.与基本类型数组的区别
1） 给数组元素复制时，必须new一下
2） 若想访问数组元素，要通过数组元素打点
<>面向对象三大特征：
1.封装
封装类：封装对象的属性，方法的行为
封装方法：封装特定的业务逻辑实现
访问控制修饰符，控制访问权限，保证数据的安全Public任何类
Protected本类，同包，派生类
默认的，本类，同包
Private私有的，本类
访问权限从大到小：public protected默认的private
作用是为了代码复用
2.继承（
extends）实现（
implements）
作用是代码复用
通过extends（继承）实现
超类（父类）和派生类（子类）
超类中存放所有派生类共有的行为
接口中存放部分派生类共有的行为
派生类（子类）存放特定的行为
派生类既能访问自己的也能访问超类的，超类只能访问自己的
方法重写，派生类的方法访问权限要大于或等于超累的
一个超类可以有多个派生类，一个派生类只能有一个超类，单一继承
一个接口可以被多个类实现，一个类也可以实现多个接口，用逗号隔开，多接口实现
传递性
Object是所有类的超类（所有类都直接或间接继承了超类）
接口可以继承接口，如果一个类既有继承又有实现，先继承后实现
3.多态
1） 任何抽象方法都是多态的，（方法被重写，什么时候重写：行为功能不一致也就是多种
形态时）发生在代码复用时
2） 任何对象都是多态的，至少有两种，一种时自身，一种是object，因为所有类都直接或
间接继承了object，放生在向上造型时
3） 强制类型转换，与instanceOf配套使用，强转成功的条件只有两种
a.引用所指向的对象就是该类型
b.引用所指向的对象继承该类或实现了该接口
强转时如果不符合上述条件，则会发生classCastExcepetion类型转换异常
<>Super
指代当前对象的超类对象
Super的用法：
Super.成员变量名，访问成员变量
Super.方法名（），调用超类的方法
Super( ),调用超类的构造方法
<>方法的重写：
遵循两同，两小，一大的原则
方法签名：方法名相同，参数列表相同；
返回值类型：如果是void或者基本类型，必须保持一致；如果是引用数据类型，派生类的
方法返回值类型必须小于或等于超类的返回值类型，否则编译错误
另一小会在API时讲
一大指的是，派生类方法的访问权限要大于或等于超类的
<>向上造型
定义：超类型的引用指向派生类的对象能点出来什么要看引用的类型
<>方法的重载与重写的区别
重载overload：发生在同一类中，方法名相同，参数列表不同
重写override：发生在父子类中，方法名相同，参数列表相同
要点：类一旦被继承，方法一定要被重写，此刻注意有可能同时发生方法重载，在判
断题中，要一一排除
<>Package包
1.避免与 类名冲突
2.同包中的类不能同名，不同包中的类可以重名
3.类的全称：包名.类名
4.包名常常有层次结构，所以建议都小写
<>Import导入
1.同包中的类可以直接访问
2.不同包中的类不可以直接访问，通过导人（
import）声明类，再访问
或者用类的全称，包名.类名（不建议，太复杂）
<>final修饰词，最终的，不可改变的，单独使用极低
1.修饰变量，变量不能被改变
2.修饰方法，方法不能被重写
3.修饰类，类不能被继承
<>Static修饰词，静态的
1.静态变量
Static修饰，存在方法区，只存储一份
通过类名点来访问
何时用：所有对象共享的东西，如图片，音频，视频
2.静态方法
Static修饰，存在方法区，只存一份
属于类，通过类名点来访问
静态方法中没有隐式this传递，不能直接访问实例成员
何时用：方法的操作与对象无关，也就是没有涉及成员变量时
3.静态块
Static修饰，属于类，在类被加载期间自动执行，（
.class字节码文件生成），一个类只被加载
一次，所以静态块只执行一次
何时用：加载/初始化静态资源（图片，音频，视频）
<>Static final常量，例如public static final int AGE = 10;(可直接省略public static final)
1.必须声明同时初始化
2.类名点来访问（遵循了static的原则），不能被改变（遵循了final的原则）
3.建议：常量名所有字母都大写，多个单词用下划线隔开4.编译器在编译时会自动将常量直接替换为具体的数字，效率高
5.何时用：数据永远保持不变，经常使用时
<>抽象方法
1.由abstract修饰
2.包含抽象方法的类，必须是抽象类
3.抽象类不能创建对象，不能（
new）所以没有意义，必须要被继承，继承该类的派生类
方法必须重写
4.抽象类的意义
1） 封装共有的属性和行为----代码复用
2） 为所有的派生类提供统一的类型----向上造型
3） 可以包含抽象方法，为所有的派生类提供统一的入口（能点出来）派生类的行为不同，
但是是同一个入口，定义了一个标准
成员内部类：
<>类中套类，外面的类被称为外部类，里面的类被称为内部类，内部类只作用于外部类，
对外不具有可见性
内部类可以访问外部类成员，私有的也可以访问，内部类有个隐式的引用指向了创建它的外
部类对象，外部类名.this----------------API时会用
匿名内部类---大大简化代码
1.若想创建一个类（派生类）的对象，并且对象只被创建一次，可以作成匿名内部类
2.在匿名内部类中默认外面的变量为final的
<>面试题：内部类有独立的.class吗？ 答：有
接口
1.接口是一种引用数据类型
2.由interface定义
3.只能包含常量和抽象方法
4.接口不能实例化，（因为是抽象方法）所以没有意义，所以要被实现，重写所有方法
一个类可以有多个接口，用逗号隔开
<>内存管理
内存由JVM来管理
1.栈内存：引用，引用的地址，正在调用的方法中的局部变量，包括方法的参数
2.堆内存：
1）new出来的东西；实例变量；
2） 垃圾：没有任何引用所指向的对象垃圾回收器（GC）不定时到内存中清理垃圾，回
收过程是透明的，可以通过调用System.gc建议JVM尽快调度GC回收。
3） 实力变量的生命周期，创建对象时储存在堆中，对象被回收时一并被回收
4） 内存泄漏：不再使用的对象没有被及时回收，严重的泄露会导致系统的崩溃，建议
不再使用的对象应及时将引用指向null
3.方法区：生成的.class字节码（类的），一个类只生成一个。Class字节码，所以只执行一
次；静态块，静态变量，所有方法（因为方法都在类中），方法只有一份，通过this.来
区分具体的访问对象
<>String:字符串类型1. Java.lang.String使用final修饰，不能被继承
2. Java中的String采用unicode字符集编码格式，任何一个字符占用两个字节的编码
3.字符串底层封装的是一个字符数组
4.字符串一旦被创建，对象的内容永远无法改变，但字符串可以被重新赋值---不变对象
<>常量池
1. Java对字符串的优化措施：字符创常量池
2.直接量/字面量直接存储到常量池中，当相同字面量再创建对象时，将复用常量池的地
址
<>String的常用方法
1. length()获取字符串长度，接收为int类型
2. trim()删除字符串左右两边的空格，接收类型为String类型
3. toUppercase();把字符串内容中，所有英文的内容改成大写，接收类型String
4. tolowercase();把字符串内容中，所有英文的内容改成小写，接受类型为string
5. startsWith();字符串内容中，判断是否是以某个字符开头的，接收类型为boolean
6. endsWith();字符串内容中，判断是否是以某个字符结束的，接收类型为boolean
7. charAt(int index);根据下标找对应的字符内容，接收为char类型
8. indexOf(String s);根据字符串内容找该字符串对应的下标，接收为