小白的JAVA基础笔记

一、循环语句：反复执行特定的代码块
1. 循环语句的格式：
1.初始化条件；
关键字（2.循环条件语句）{
3.循环体语句；
}
2.循环语句的四要素：
1.初始化条件
2.循环条件语句
3.循环体语句
4.控制条件语句
3. 循环语句的分类：
1.while循环
2.do-while循环
3.for循环
4. 断点调试：
1.打断点
2.右键debug as–>java application
5.break:退出循环体或者Switch语句体
continue:1.表示退出本次循环，执行下一次循环
2.退出本次循环，直接执行控制条件语句（for循环）
3.一旦碰到continue关键字，无论其下面有多少行代码都不会被执行
return：表示退出当前所在的方法
return value： 表示退出当前所在的方法的同时还会返回结果给调用者
二.方法
1.方法的概念：完成特定功能的代码片段
数学中成为函数：Y= f（x,y)
方法的格式：
访问权限修饰符 返回值类型 方法名称（参数类型 参数名1，参数类型 参数名2，…）[throws 异常类名]{
方法体；//method stub
return 返回值；
}
方法的三要素（重点）
1.返回值类型
2.参数列表
3.方法名
2.方法重载：
发生在同一个类中，方法名称相同，参数列表 （参数个数，顺序，类型）不同构成重载
方法重载同时也是多态的一种表现形式
3.递归：递归是一种算法，递归在java当中就是方法中调用自己本身

三.数组
1.数组的概念：数组属于引用类型，数组的本质就是一个容器，存放一组相同数据类型变量的数据容器
2.数组的格式：数据类型[ ] 数组名； java
数据类型 数组名[ ]； C语言
特点：1.数组的本质就是一个引用类型的变量，既然是变量就必须满足先声明在赋值再使用
2.数组的初始化：a.声明 b.赋值 c.使用
3.数组的内存分配
数据类型[ ]数组名=new 数据类型 [长度]；
4.访问数组的元素
arr[下标/索引]
java.lang.nullpointerexception
异常名称：空指针异常
产生原因：对象没有new就访问了对象的成员
解决办法：new
java.lang.arrayindexoutofboundsexception
异常名称：数组越界
产生原因：访问了不在数组定义范围内的索引
解决办法：检查索引是否超出了数组定义的范围
3.数组的初始化：
静态初始化：数据类型[ ]数组名=new 数据类型[ ]{元素1，元素2，元素3…}; 用作匿名对象
数据类型[ ]数组名={元素1，元素2，元素3…}; 用作初始化
动态初始化：数据类型[ ]数组名=new 数据类型[长度]；
二者区别：静态初始化在初始化的同时会给每一个元素赋值，不需要指定数组的长度，
不需要指定数组的长度，系统会自动根据元素的个数去动态计算数组的长度。
动态初始化在初始化的同时由系统分配默认值，但是必须指定数组的长度
4.值传递和引用传递
1.值传递的本质传递的是数值本身，引用传递的本质传递的是地址
2.如果传递的是地址，那么通过地址改变了堆区空间的数值，将会影响到所有指向该堆区的引用
5.数组的查找
基本查找：针对所有的数组都可以
二分法查找：针对有序的数组效率可以提高非常多
6.数组的排序
八大排序算法：冒泡 选择 插入 快速 希尔 堆 归并 基数
冒泡 规律：1.相邻两个数进行比较，大的数冒泡，交换两个数的位置
2.一共比较了arr.length-1趟
3.每一趟比上一躺少比较一次
选择 规律：1.每一趟初始比较的位置是上一躺位置+1
2.前面的元素依次和后面每一个元素进行比较，小的往前放
foreach遍历数组
集合和数组专属遍历方式，底层还是使用普通for遍历
格式：
for（数据类型 变量名：数组名/集合名）{
}
普通for和foreach的区别：
1.简化了遍历 2.没有索引
7.为什么需要可变参数？
针对参数类型相同但是参数的个数不同的情况下非常方便
可变参数：是一种形参类型
格式：数据类型…参数名
注意事项：1.可变参数的本质是数组
2.可变参数的…可以放在参数类型和变量名中间的任意位置
3.可变参数必须出现在参数列表的最后面
8.为什么需要动态扩容？
数组的长度一旦初始化，就固定了，如果需要给数组添加一个元素非常麻烦，需要自己通过代码来实现
实现思路
像数组中添加一个元素：
在某个索引处插入一个元素
删除某个索引对应元素
9.自定义工具类MyArrays
实现的功能：
增加add 插入insert 删除delete 修改：update 查询 get

四.面对对象
类和对象的理解
类：1.类是用来描述事物
2.类是抽象的
3.类可以理解为一个模板，是属性和方法的集合
4.java中用class来描述类
5.类是java当中最基本的组成单位
6.类就是用来组织代码（方法归类）封装数据（属性封装）的
对象：1.对象一定是客观存在的，是具体的
2.万事万物都是对象
3.对象是在类的基础上创建的
4.对象又称为实例/引用/变量
类的定义：
java中用class描述类
成员变量表示就是事物的属性
成员方法表示就是事物的行为
格式
[访问权限修饰符]class类名{
成员变量
成员方法
}
如何创建一个对象：类名 对象名=new 类名（）;
如何访问一个对象：
访问对象的属性：对象名.属性
访问对象的方法：对象名.方法名（）
成员变量和局部变量的区别
1.定义的位置不一样
成员变量：定义在类体以内，方法体以外
局部变量：方法的声明生（形参），或者方法体内
2.内存的位置不一样
成员变量：在堆区分配内存空间
局部变量：在栈区分配内存空空
3.初始值不一样
成员变量：成员变量默认有初始值，系统会赋予如下初始值
byte short int long 0
float double 0.0
boolean false
char \u0000
引用类型 null
局部变量：默认没有初始值
4.生命周期不一样
成员变量:随着对象的创建而创建，随着对象的销毁而销毁
局部变量：随着方法的调用而创建，随着方法的销毁而销毁
5.当成员变量和局部变量重名的时候，局部变量优先（就近原则）

匿名对象：本质就是没有名字的对象
特点：
1.匿名对象没有名字
2.匿名对象只能够调用一次
3.由于匿名对象使用完毕之后立刻就成为垃圾对象，等待垃圾回收器在空闲的时候回收垃圾
一般可以节约内存资源，在java中应用少，在android应用多
也可以简化编程[参数传递]
什么是垃圾对象？
1.匿名对象
2.对象被赋值为null
3.对象所在的方法调用完毕
4.当主方法调用完毕
5.当对象被重新new
封装
private关键字：它本质是一个访问权限修饰符，用来放置外界访问成员变量
封装步骤：1.给需要封装的成员加上访问权限修饰符（private）—防止外界直接通过，直接访问成员
2.对外界提供公共的访问方法（set/get方法）—提供外界对内部成员的访问通道
3.在读写方法中添加数据校验代码—可以对成员的访问提供数据控制（看需求可选择）
为什么需要this关键字？
-----当局部变量和成员变量重名的时候需要使用this
this本质就是一个变量/地址/实例/引用，表示当前对象
this理解
1.创建任何一个对象，都会默认创建一个this变量指向同一个堆区的空间
2.this的设计理念代表代词 我的 概念，只能够出现在类的内部
3.this可以完全理解为一个引用，一个本类的实例，或者本类的对象
4.默认访问内部类的成员变量或者成员方法，都会省略一个this
5.this本身就代指当前对象，谁调用this本身就是谁
构造方法：本质就是一个方法而已，只不过能够帮助我们初始化成员
好处：1.能够快速初始化成员
2.能够在堆区为对象分配空间
格式：[访问权限修饰符] 方法名（参数列表）{
方法体；
}
特点：1.构造方法没有返回值，连void都没有
2.构造方法的方法名必须和类名保持一致
3.构造方法用来给成员快速初始化
4.如果你没有书写无参构造方法，系统会默认帮我们编写一个无参构造方法
5.如果你一旦编写了一个带参构造方法，就会覆盖系统写的无参构造方法
6.养成一个好的习惯：书写每个类都必须显示定义无参构造方法
无参构造方法的意义：
1.为一些不需要外界传入的成员赋值，同时会在对象创建的时候初始化
2.如果你一旦编写了一个带参构造方法，就会覆盖系统写的无参构造方法，当你再使用无参构造方法的时候会编译报错
3.反射中大部分都是创建无参构造方法，很多框架都是利用反射，所以如果你不提供无参构造方法，很可能框架报错
构造方法本质还是方法，可以方法重载

访问构造方法的方式有3种
1.new关键字 会创建对象
2.this关键字 不会创建对象
3.super关键字 不会创建对象
构造方法不可以递归使用，构造方法之间不能够嵌套使用
this除了可以访问本类的成员变量和成员方法，还能够访问本类的构造方法，this访问构造方法必须出现在构造器的第一句
总结：给成员初始化 3种方法
1.通过get/set方法 2.通过构造方法 3.通过自定义方法

类的组成：
class 类名 {
成员变量【封装】
构造方法
无参构造方法
全参构造方法
成员方法
普通方法
get/set方法【成员的读写方法】
}
为什么需要学习static?
静态变量，为所有对象共享使用
static概述：静态的/共享的
static的特点
1.静态变量属于类，而不属于具体的对象
2.在静态环境中，只能够访问静态变量，不能够访问非静态变量
3.在非静态环境下，既能够访问静态变量，也能够访问非静态变量
4.静态变量的访问格式：
1.通过对象访问
2.通过类名访问
3.通过set方法访问
5.当有一个对象修改了static属性的值，任何一个对象都会被影响
6.静态修饰方法或者变量有意义吗？
变量：共享
方法：方法是用来完成特定功能的，给别人调用，而静态修饰的方法正好可以通过类名直接访问
方便调用，不需要创建对象，常用来编写工具类Math
书写工具类的步骤
1.构造方法私有
2.方法成员全部静态化
7.static环境中不能够出现this和super
8.static不仅可以修饰变量和方法，还能够修饰代码块，以及类（保证是内部类）

五.代码块：大括号包裹的就称为代码块
代码块的分类：
1.局部代码块：定义在局部位置，限定局部变量的作用域
2.构造代码块：定义在成员位置，用来抽取多个构造方法中的重复代码，可以简化编程
在构造方法之前执行，并且每次创建对象前都会i执行一次，优于构造方法之前执行
3.静态代码块：
定义在成员位置，在构造代码块和构造方法之前执行，并且只会执行一次
作用：
a.用来加载一些预定义的资源，比如说数据库的连接，配置文件的读取
b.用来初始化静态成员

执行时机和执行顺序：
静态代码块>构造代码块>构造方法
构造方法在对象创建的时候执行，可以执行多次
构造代码块在对象创建之前执行，可以执行多次
静态代码块在类第一次出现（类加载）/或者第一次使用的时候执行，只能够执行一次
4.同步代码块
六.继承
格式：通过extends关键字可以实现类与类的继承
class 子类类名 extends 父类类名{ }
缺点：耦合性提高，让类与类之间产生了关系，容易牵一发动全身
继承要慎用，降低了扩展性和维护性
什么时候使用继承？
1.一般在编写代码的时候出现了重复代码，我们可以将重复代码向上抽取成为一个父类的baseacitvity basedao
2.当某个类的设计非常复杂的时候，可以使用继承
3.让类与类产生了关系，这是多态的必要条件
继承的注意事项：
1.单一继承性 2.支持多层继承class C extends B { }class B extends A{ }
3.父类成员使用private修饰，理解为不能继承，所以父类成员一般都会用public 或者 protected修饰
4.如果一个子类继承了父亲的属性和方法，同时还可以有自己的方法
5.当子类成员和父亲成员重名的时候，子类优先
6.子类不能够继承父类的构造方法，但是子类可以访问父类的构造方法
super关键字
this和super的区别：
this可以理解为当前对象，谁调用this就代指那个调用者对象，每次创建一个对象，默认都会创建一个this变量指向同一个堆区空间
super本质是父类存储空间的标识，但是你可以理解为父类对象，那么同样可以使用super这个关键字来访问父类的成员
注意：
1.任何一个类的无参或者带参构造方法的第一句都默认省略super（）；
2.任何一个类都直接或者间接继承自object类
3.设计object类，满足了万事万物皆对象的原则
访问根类object的无参构造意义何在？–加载object类中静态成员和静态代码块
4.创建一个子类对象默认会去调用父类的构造方法，那么有没有在创建子类对象的同时也创建了父类对象呢？
----没有创建父类对象，本质就相当于访问了一个普通方法，创建对象开启空间需要new关键字
5.super访问父亲带参构造方法的意义？–帮助子类初始化父类继承下来的成员，简化编程
6.静态环境/静态上下文（static修饰的方法），不能够出现this和super
7.super必须出现在构造方法的第一句，this和super不能共存

访问权限修饰符：public >protected> default> private
1.public对一切类可见
2.protected对同包下和不同包的子类可见
3.default仅对同包下可见
4.private仅对本类可见
访问权限修饰符可以修饰成员变量，成员方法，还可以修饰类（只有public可以）
在这里需要注意，其实protected/private也可以修饰类，但必须是内部类
方法重写特点：
1.发生在具有子父类的两个类中 2.方法名相同3.参数列表完全相同4.返回值类型可以相同或者是其子类5.访问权限修饰符不能够严于父类
private修饰的方法不能够被继承，所以不能够被重写
注意事项：
1.父类中私有方法不能被重写
2.构造方法不能被重写
3.子类重写父类方法时，访问权限不能更低
4.重载和重写的比较（二者是完全不用的两个概念毫无关系）

final
修饰变量成为常量，不能够被二次赋值
局部变量
可以暂时不给出初始值
成员变量
在声明的时候必须给出初始值
修饰方法不能够被子类重写
修饰类不能够被子类继承 string类是final修饰的

七.多态
概述：同一个方法在不同的类下体现出来的不同的实现（java）
父类引用指向子类对象 （内存）
多态的必要条件：
1.必须存在继承关系
2.必须存在方法重写
3.必须存在父类引用指向子类对象
利用多态访问成员的特点：
成员变量
编译时期看左边类型，运行时期看左边类型
成员方法
编译时期看左边类型，运行时期看右边类型
构造方法
先访问父类的构造方法，帮助子类初始化父类继承过来的成员
静态方法
编译时期看左边类型，运行时期看左边类型
多态的缺点：父类引用无法访问子类所特有的方法
解决办法：向下转型
格式：<父类型> <引用变量名>=new <子类型>（）;（向上转型，自动转换）
<子类型> <引用变量名>=（<子类型>） <父类型的引用变量>;（向上转型，自动转换）
instanceof关键字：测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据
记住：instanceof通常和向下转型结合使用