这是本人在学习Java基础时的笔记，仅供参考。
如有错误，请指出，谢谢啦！
目录
一、接口：
一、集合概念：是一个用于存储多个对象的容器(对象).容器内的对象
三、集合框架中包含多种接口，抽象类，实现类等,用此来满足我们所需要的用于存储数据的数据结构。
【1】接口、包、类、异常等
一．接口
API:应用程序编程接口，即jdk文档手册，里面以类的形式提供了
很多常用的功能。
常用的包与类：
java.lang包：因为常用，所以不需要导包
字符串，线程
java.util包: 数组工具类，日期，集合等
java.net包: 网络相关的 类型
java.io包: 输入输出类型
java.math包： 数学应用的相关类型
打包工具:javadoc
(1)使用命令提示符界面：
类信息中没有声明包，即使用默认包
javadoc -d path *.java
path：生成api文档的位置
类信息中声明了包 如:package com
javadoc -d path nameOfPackage
如:
javadoc -d .\doc com
源文件在不同包下:
javadoc -d path nameOfPackage1 nameOfPackage2....
如:
javadoc -d .\doc com demo
(2)借助eclipse
export--java--javadoc-->
选择javadoc命令的路径
选中要生成文档的项目
选择生成文档的位置
===========================================
二．异常：
在程序开发过程中出现的不正常情况，就是异常。比如，
除数是0，参数为null,调用参数的成员变量或者方法，数组下标越界
异常分为两大类型：
(1)exception：程序员可以解决的:空指针，除数是0，数组下标越界
(2)Error：程序员无法解决的:如内存溢出
Throwable是这两种类型的父类
exception的分类:
按照编译器是否检查进行分类：
非检查性异常：也称之为运行时异常，即，编译器在检查语法期间，不做
异常检查。
检查性异常： 也称之为编译时异常，此时，编译器会强制检查语法中的异常情况
如有异常，在编译期需要做异常处理
exception的结构:
异常的处理:
（1）当异常出现时，终止程序
(2)当异常出现时，我们使用处理机制进行处理异常。无序终止程序
体验度:尽可能的选择异常处理机制。
异常处理机制：
基本思想：
在可能出现异常的代码块区域，进行尝试检查，如果
出现了异常信息，我们将这些信息封装成某一异常类型的对象。
然后进行捕获与处理
try{
可能出现异常的代码块
/*如果有异常，jvm会将异常信息，封装成对象
将地址信息赋值给catch中的形参
*/
}catch(Exception e){
进行处理e
}
多catch语句块情况：
当我们在尝试捕获异常对象时，想对多种不同的异常对象分别处理时，
需要使用多个catch语句块
说明: 当在try中出现了异常信息，那么就不会再执行try中代码块的
后续部分。进入相应的catch代码块中执行处理。
多catch语句块情况下，catch处理的异常种类书写顺序：
先写子类异常类型，再写父类异常
throw：抛出关键字，在本方法中出现的异常，不做try-catch处理。
而是抛给调用者处理。需要使用throw关键字。
throws:声明异常关键字，通常用于方法的定义上，用于通知调用者
当throw的异常对象为检查性异常，方法上必须throws此异常类型
如果throw的异常对象为非检查性异常，方法上不必throws此异常类型
方法重写时的throws的用法
可行的:
(1)可以相同
(2)可以是部分
(3)异常的子类型可行,可以是多个子类型
不行的：
(1)不同的异常类型，不可以多声明
(2)异常的父类型不行
finally:
是为try-catch提供了统一的出口。不管try与catch语句块是否
发生了异常，最终都会执行finally里的代码块 。
通常用于处理一些资源的关闭等操作：
如读取文件时关闭操作，或者是删除临时文件
/ finally语句块可选。
【2】字符串
一．StringBuilder:可变字符串类型:
(字符串:底层是字符数组，及其对数组的操作)
特点:
(1)此类型是final修饰的
(2)没有重写equals方法
(3)此类型提供的大多数方法都带有返回值，
即: return this 返回同一个地址
二．构造器:
StringBuilder()
///
构造了一个空的StringBuilder对象，初始容量为16。
StringBuilder(String str)
创建一个指定字符串的StringBuilder对象
常用方法：
int length()：
返回有效字符的长度。
StringBuilder append(Type a):
将参数a追加到StringBuilder对象里，返回此对象
StringBuilider insert(int index,Type a);
将参数a插入到对象的下标index处
StringBuilder delete(int start,int end);
删除此对象里的部分字符，从start开始，到end结束，注意：包前不包后
StringBuilder replace(int start,int end,String str);
使用str替换此对象从start开始到end结束的子串
StringBuilder reverse():
将StringBuilder对象的内容进行翻转
StringBuffer：此类与StringBuilder用法一模一样。
但是:
在线程安全上考虑：
StringBuffer线程安全
StringBuilder线程不安全
在执行效率上：
StringBuffer效率低
StringBuilder效率高
练习:测试两种类型的效率高低。
================================================
String类型:(底层是字符数组+对数组的操作)
特点:
(1)是不可变的字符串类型，(不可变:对象的内容不能更改)
(2)final修饰的类型
(3)字符下标(索引/index)从0开头
(4)重写了equals方法和toString方法
(5)默认使用的是unicode字符集，任意字符都占两个字节。
构造器:
String():
创建一个空字符序列的字符串对象
String(byte[] bs)
创建一个字符串对象。使用默认字符集进行解码的字符串。
String(byte[] bs,String charset)
将字节数组使用指定字符集进行解码成相应的字符串对象
String(char[] ch)
将字符数组转换成字符串对象
String(String str)
指定一个字符串字面量创建一个字符串对象
常用方法:
int length():
返回字符串对象的字符个数
char charAt(int index):
返回此字符序列中指定索引处的字符
String concat(String another):
将指定字符串another拼接到此字符序列的末尾，返回新对象
boolean stratsWith(String prefix)/endsWith(String suffix)
查看此字符序列是否以prefix为前缀/以suffix为后缀
byte[] getBytes():
将此字符串按照默认字符集编码成字节序列，返回一个新的字节数组
byte[] getBytes(String charset)
将此字符串按照指定的字符集编码成字节序列，返回新的字节数组
三．查找字符串中的字符/子字符串的位置
int indexOf(int ch)
返回字符ch在此字符串中第一次出现的下标(索引/位置)
int intexOf(int ch,int fromIndex):
返回字符ch从此字符串fromIndex下标开始，往后第一次出现的位置
int indexOf(String str):
int indexOf(String str,int fromIndex):
注意:返回-1，说明要找字符/子字符串 不存在查找序列中
int lastIndexOf(int ch);
int lastIndexOf(String str)
int lastIndexOf(int ch,int endIndex)
int lastIndexOf(String str,int endIndex)
查找字符/子字符串截止到某一下标时，最后一次出现的位置。
上述四个方法：
查找字符/子字符串在此字符序列中最后一次出现的位置,找不到返回-1
四．截取子字符串的方法：
String substring(int beginIndex)
从此字符序列的beginIndex开始截取，截取到最后
String substring(int beginIndex,int endIndex)
从此字符序列的beginInde开始截取，截取到endIndex,包前不包后
字符串转成字符数组的方法：
char[] toCharArray()
将此字符序列变成字符数组
字符串中的字母转成大写/小写
String toUpperCase()
将字符串中的字母都变成大写，返回新字符串
String toLowerCase()
将字符串中的字母都变成小写，返回新字符串
前后去空格的方法：
String trim()
去掉此字符序列的前与后的空格
将任意参数变成字符串对象
static String valueOf(Type v);
将参数v变成字符串对象
equals方法与==的区别
==:用来比较是不是同一个对象
equals:用来比较两个对象的内容是否相同
String类型中重写了equals方法
常量池:
jvm在使用字符串类型时，为了提高内存的使用率，当使用字面量(常量)
进行给变量赋值时，在方法区内提供了用于存储字面量对象的一个常量池。
原理:
当使用字面量赋值时，先去方法区内的常量池中查询是否有相同字面量的对象，
如果有，就返回常量池中对象的地址，没有的话，在常量池中创建此字面量的对象
再返回。
思考题：内存中有多少个对象
String s1 = "123";
String s2 = "456";
String s3 = s1+s2;
String s5 = new String("123"+"456");
【3】面向对象、数组
一．面向过程:C,Basic,Pascal
核心思想: 自顶向下，逐步细分，模块化
程序的基本单元:函数
针对于函数来说：会接收一些数据，进行处理，然后再输出
一些数据。
主函数
函数1
函数2 函数3
如：吃(猪八戒，西瓜)
面向对象：C++,java,C#...相对面向过程，简单，好学。
核心思想：使用类，对象，继承，封装，消息，动态绑定，静态绑定等进行程序设计
程序的基本单元：类
如:
首先：设计猪妖类型，
然后: 实例化一个猪妖
其次: 初始化信息
使用: 猪八戒.吃(西瓜)
抽象数据类型:用不同类型的数据的组合来描述一种新的事物。
如:描述人类
String 姓名
int 年龄
char 性别
double weight
String[] 爱好
二．类:用来定义一种抽象数据类型
定义上述描述的新的事物
public class Person{
//成员变量
String name;
int age;
char gender;
....
/*方法
1:可以定义这种类型的一些共同行为
2:可以使用这些方法来操作成员变量
*/
}
三、对象:是类产生的个体，即类的实例化
在程序的逻辑中被使用。
如何实例化和初始化？
new 构造方法(有参传参)
null与NullPointerException
null:是引用类型的默认值
NullPointerException:是程序在运行时产生的一种异常
如何产生的??
当引用变量没有指向任何对象时，
调用了类型中的成员变量或者方法
reg:
Person p = null;
p.eat("面包");
p.name = "张三";
引用变量:简称引用，
存储的是堆中对象的地址信息，我们可以理解为变量
指向了堆中的对象
方法
1、方法签名: 方法名+参数列表
2、方法重载：
在同一个类型中，方法名相同，参数列表不同，
即方法的重载
3、定义语法：
修饰词 返回值类型 方法名(....){
}
4、调用语法:
没有static修饰的方法
必须使用引用.方法(有参传参);
四．构造方法：
作用:用来初始化对象的成员变量
定义语法: 修饰词 类名(...){}
调用语法: new 构造方法();
无参构造器:没有定义构造器时，系统会默认提供无参构造器
注意:只要定义了构造器，系统不再提供默认构造器
成员变量与局部变量的区别：
成员变量
定义位置:在方法外，类体中
默认值:有默认值,构造器中可以不对成员变量初始化
内存位置:在堆中
生命周期:从对象实例化开始出现，到对象消失
局部变量
定义位置:在方法内(包含小括号内的形参)
默认值: 没有默认值，必须初始化再使用
内存位置:在栈帧中
生命周期:从声明时开始，到方法结束后，栈帧消失时。
内存管理:
jvm将内存分成三大主要区域，堆，栈，方法区，用来存储数据。
堆(heap):存储new出来的对象，给成员变量分配空间
栈(stack):jvm在执行程序时，在栈中，会为每一个方法分配一
个空间(即栈帧)，用来存储方法的局部变量。
方法区:用来存储jvm加载的字节码文件的信息(类的信息)
包含类的方法，方法只有一份，堆中的对象共享
这份方法，在使用非static修饰的方法时，需要
对象来调用(即动态绑定到对象上)
垃圾回收机制：(GC)
jvm的一个独有线程(程序)，用于回收没有任何引用指向的对象。
System.out.println((new Person()).name);
上述产生的对象，以后再也无法使用，如果类似的这样情况
有很多，对象来不及被处理，内存剩余空间就会越来越小，
有可能出现内存溢出情况。
因此需要一个处理机制，即垃圾回收机制。没有被引用的对象
会被视为垃圾，等待GC被回收
(因为有垃圾绘制机制，所有java程序猿无需单向内存溢出或泄露情况)
================================================
五．this关键字：
在普通方法或构造器中，操作的成员变量如果与局部变量名称相同时，
为了避免出现歧义，应该在成员变量前使用this.进行区分
当没有歧义时，this.可以省略不写
在构造器中：还可以使用this关键字调用本类中的其他构造方法
语法格式: this(有参传参)
只能在构造器中的首行首句上使用
==============================================
经典俄罗斯方块游戏：
画面最多能放入20行，10列的方块
画面中的最小单元：
是一个小方块
设计需求分析: 最多有200个方块，这些方块有共同特征
有共同行为
最小单元： Cell来定义方块这种事物
成员变量： 行号row,列号col
方法: drop()
left()
rigth()
重载上述三个方法，通过形参决定移动的步数
toString();
===========================================
数组：
基本数据类型数组，元素是基本类型的数据。
引用数据类型数组，元素是对象
初始化的方法：
静态初始化：
元素类型[] 变量名 = {}
动态初始化:
(1)规定长度的
(2)不规定长度的
引用数据类型的数组使用规定长度的方式进行初始化时，
默认值是null;
如:
Cell[] cs = new Cell[10];
cs里有地址，数组对象的地址。此对象里有10个null。
第一个元素存储(0,3)的方格
cs[0] = new Cell(0,3);
第二个元素存储(0,4)的方法
cs[1] = new Cell(0,4);
PS:引用类型的数组对象内，存储的是元素对象的地址信息
===================================================
比最小单元大点的
游戏中有很多T对象，我们可以抽象出来一种T类型
所有的T对象的共同特征：
四个方格
所有的T对象的共同行为：
向左 moveLeft()
向右 moveRight()
向下 moveDrop()
重载 上述三个方法
toString()
public class T{
Cell[] cs;
public T(){
cs = new Cell[4];
...
}
}
格式自动对齐快捷键：ctrl+shift+f
【4】继承
一．继承:
现实世界中：通过分析多种类型，然后发现有一些共同特征和共同行为
再将这些种类，归纳为一种新类型
如: 黄色皮肤的人
白色皮肤的人
黑色皮肤的人
|
人
再如: 小狗 --能动，能吃，能睡，能叫(汪汪)
小猫--能动
最低0.47元/天 解锁文章
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
