Java基础学习
Java 基础学习总结
1. 了解Java
Java是一门面向对象编程语言，Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点 。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。
2. 基础知识
2.1 注释
Java一共有三种注释，分别是文档注释、单行注释、多行注释。如下：
文档注释：
/**
* @author 我是文档注释
* @version 1.0
*/
单行注释：
//我是当行注释
多行注释：
/*我是
多行
注释
*/
2.2 标识符
对于标识符，我觉得还是直接定死比较好，比较不同的语言有它的规则，比如java可以用中文（不提倡)。所以，还是用各种语言都有的规则以免每学一种语言就要记一便它自己的规则。因此标识符可以简单的这样记：
类：首字母大写后面驼峰原则，如BirdPeople
变量：首字母小写和驼峰原则，如studentName
常量：以大写字母和下划线，如MAX_VALUE
2.3 基本数据类型
Java基本数据类型一共有八种
数值型：
①整数类型：
| 类型 | byte | short | int | long |
|---|---|---|---|---|
| 字节 | 1 | 2 | 4 | 8 |
②浮动类型：float、double
| 类型 | float | double |
|---|---|---|
| 字节 | 4 | 8 |
③字符型：char（2字节)
④布尔型：boolean(1字节)
2.4 运算符
算术运算符：++、--、+、-、*、/、%
赋值运算符：=
扩展运算符：+=、-=、*=、/=
关系运算符：>、<、>=、<=、==、!=、instanceof（判断该对象是否属于该类）
逻辑运算符：&&、||、！、^
位运算符: &、|、^、~、>>、<<
条件运算符: ? :
字符串连接符：+
2.5 简单的输入输出
Scanner scanner=new Scanner(System.in);
System.out.println(scanner.next());
注：要记得引入Scanner的包。
3. 流程控制语句
3.1 if
1.
if (条件){
内容
}
2.
if (条件){
内容
}else{
内容
}
3.
if (条件){
内容
}else if (条件){
内容
}else{
内容
}
3.2 switch
switch (表达式){
case 值1:
内容;
[break;]
case 值2:
内容;
[break;]
......
[default:
内容;]
}
3.3 while
1.
while (条件){
内容;
}
2.
do {
内容;
}while (条件);
注意：do......while最后有分号
3.4 for
1.
for (初始表达式;布尔表达式;迭代因子){
循环体;
}
2.
for (初始表达式:循环变量) {
循环体;
}
3.5 方法
1.语句块：
{
内容
}
2.方法声明：
修饰符 返回值 方法名(型参列表){
内容;
[rturn]
}
如下：
public void getname(int n1,int n2){
System.out.println(n1+n2);
}
3.方法重载：
①方法名相同
②形参类型、形参个数、形参顺序不同
3.6 递归
- 调用自身
- 要有递归头，用来结束递归循环
public int add(int num){
if(num==1){//递归头
return 1;
}else{
return num+add(num-1);
}
}
4. 面向对象基础
4.1 类的编写
类定义方式：[修饰符] class 类目{}
注：每一个源文件必须有且只有一个public class,并且类名和文件名保持一致。
类中属性定义方式：[修饰符] 属性类型 属性名=[默认值];
类中构造器定义方式: public 类名([形参变量]){}
示例如下：
class Student{//类
//属性
public String name="小明";
int age;
//构造器
public Student(int age){
this.age=age;
}
}
4.2 类的使用(实例化)
类名 实例化对象名=new 类名([形参变量]);
示例如下：
Student student=new Student(2);
4.3 构造器的重载
构造器也称构造方法，也是与方法一样可以重载的。
示例如下：
class Student{//类
//属性
public String name="小明";
int age;
String tel;
//构造器
public Student(){
}
public Student(int age){
this.age=age;
}
public Student(int age,String tel){
this.age=age;
this.tel=tel;
}
}
实例化：
Student student0=new Student();
Student student1=new Student(2);
Student student2=new Student(2,"12345678910");
4.4 this
- 在构造器中指要初始化的对象。
- 在方法中指调用该方法的对象。
- this不可用于static方法中
4.5 static关键字
- static修饰的成员变量称为静态成员变量，其被该类的所有实例共享（即不管实例化多少个对象，静态成员变量都是指向同一个），并且在类被载入时初始化。
- 调用方法：对象/类名.类属性/方法。
如下：
Math.PI
- 不可在static方法中直接访问非static的成员。
4.6 包
包的引入：import java.util.* 星号表示引入所有的类。
JDK中的常用包：
| java.lang | 包含一些java语言的核心类，如String、Math、Integer、System和Thread。 |
|---|---|
| java.awt | 包含抽象窗口工具集的类，用于构建图形用户界面（GUI） |
| java.net | 包含执行与网络相关的操作的类 |
| java.io | 包含能够提供多种输入输出功能的类 |
| java.util | 包含一写实用的工具类，如与日期、日历相关的函数等 |
5. 面向对象进阶
5.1 继承
可用于解决重复造轮子的麻烦。继承的使用要注意以下几点：
- Java中类只有单继承，接口有多继承
- 子类可以继承父类 的所有属性和方法（构造方法除外），但不一定都能使用（例如，父类的私有private的属性和方法）。
- 用extends来继承，如果没有则是继承java.lang.Object父类。
- 可用对象 instanceof 类运算符判断该对象是否为为该类或子类创建。
继承中方法的重写注意以下几点：
- 方法名、形参列表相同。
- 返回值类型和声明异常类型，子类要小于等于父类
- 访问权限，子类大于等于父类
继承示例：
class Person{//父类
String name;
int age;
public void a(){
System.out.println("aaa");
}
}
class Studnet extends Person{//子类继承父类
String ID;
//拥有父类的属性和方法
public Studnet(String name,int age,String ID){
this.name=name;
this.age=age;
this.ID=ID;
this.a();
}
}
5.2 封装
封装用于可以方便外部的调用，同时，增加安全性。
需要用到访问修饰符：
| 修饰符 | 同一个类 | 同一个包 | 子类 | 所有类 |
|---|---|---|---|---|
| private | * | |||
| default | * | * | ||
| protected | * | * | * | |
| public | * | * | * | * |
封装类的细节：
- 属性一般使用private访问权限
- 属性提供相应的get/set方法来访问属性
- 方法通常用public修饰除了一些由于辅助本类的方法可用private
封装示例：
class Person{
private String name;
private int age;
public void a(){
System.out.println("aaa");
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
5.3 多态
多态是指同一个方法由于调用的对象不同有不同的结果。
多态要注意以下几点：
- 多态是方法的多态
- 要达到这三个必要条件：继承、方法重写、父类引用指向子类对象。
多态示例：
class Animal{
public void shout(){
System.out.println("动物叫声");
}
}
class Dog extends Animal{
public void shout(){
System.out.println("汪");
}
}
public class Chapter01 {
public static void main(String[] args) {
//实例化并调用
Animal animal=new Dog();
animal.shout();
}
}
5.4 接口
接口可以说是一种规则。
接口要用到关键字interface
声明格式：
[访问修饰词] interface 接口名 [extends 父接口1，父接口2......]{
常量定义;
方法定义
}
注意：
- 访问修饰符：public不管写不写都是
- 接口可以多继承
- 接口的变量只能是常量，以public static final修饰，不写也是
- 方法只能以public abstract，不写也是
6. 异常机制
异常有两种运行时异常和已检查异常，前者程序员无法解决。
已检查异常解决方法：
- 捕获异常，使用try...catch...finally
- 声明异常，使用throws抛出异常
- 自定义异常，自己定义一个异常类要继承Exception类，然后要抛出异常的方法throws抛给自定义的异常类使用throw抛给自定义异常类实例
自定义异常示例：
class AgeExecption extends Exception{
//默认构造器
public AgeExecption(){}
//带有详细详细的构造器，信息在message中
public AgeExecption(String message){
super(message);
}
}
class Person{
private int age;
public void setAge(int age) throws AgeExecption{
if(age<0){
throw new AgeExecption("人的年龄不得小于0");
}
this.age=age;
}
}
7. 数组
7.1 数组的创建和初始化
创建:
type[] arrayName;//推荐
type arrayName[];
初始化：
//1.静态初始化
int[] a={1,2,3};
//2.动态初始化
int[] a=new int[1];
a[0]=1;
//3.默认初始化
int[] a=new int[1];//默认为0；boolean类型默认false;String类型默认null
7.2 数组常规操作
-
遍历
可以使用for或for...each循环解决
-
排序
Arrays类有sort()方法，也可使用Comparable接口排序
示例：
//sort()方法是二分法排序，小到大排 int[] a= {4,2,1,3,5}; Arrays.sort(a); //Comparable接口排序 class People implements Comparable { int age; public People(int age){ this.age=age; } public String toString(){ return String.valueOf(this.age); } @Override public int compareTo(Object o) {//重写此方法 People people=(People) o; if(this.age<people.age){ return -1; } if (this.age>people.age){ return 1; } return 0; } } public class Chapter01 { public static void main(String[] args) { People[] people={new People(1),new People(3),new People(2)}; Arrays.sort(people); System.out.println(Arrays.toString(people)); } } -
复制
可以使用System类里的
static void arraycopy(源数组,源数组开始赋值下标,目的数组，目的数组开始存放下标,复制的长度)方法
8. 常用类
8.1 包装类
基本类型变包装类：包装类.valueOf(基本类型)
包装类变基本类型：包装类实例对象.基本类型Value();
示例:
Integer a=Integer.valueOf(1);
int b=a.intValue();
注：包装类会自动装箱和自动拆箱。
示例：
Integer a=1;
int b=a;
包装类的缓存：整型、char型对应的包装类在自动装箱时，对于在-128~127之间的值会进行缓存处理。
| 基本数据类型 | 包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
数据型的类都是java.lang.Number的子类，都有实现intValue()、longValue()、floatValue()、doubleValue()方法，所以是可以相互转换型的。
8.2 字符串相关类
8.2.1 String类
创建：
String str=new String("内容");
String类字符串是不可变对象。
8.2.1 StringBuffer和StringBuilder类
这两个字符串类的字符串是可变长度的字符串。
前者线程安全，但效率地，后者相反。
8.3 时间相关类
8.4 Math类
8.5 Random类
Random random=new Random();
random.nextInt();//随机生成[0,1)之间的int类型数据
random.nextInt(10);//随机生成[0,10)之间的int类型数据
int i=10+random.nextInt(10);//随机生成[10,20)之间的int类型数据
8.6 File类
9. 容器
9.1 List接口
List实现的子接口有ArrayList、LinkedList和Vector
ArrayLists:查询效率高，增删效率低，线程不安全
LinkedList:查询效率低，增删效率高，线程不安全
Vector:线程安全，效率低
9.2 Set接口
Set容器特点：无序、不可重复。无序没有索引只能通过遍历方法查找，不可重复不能加入重复的元素。
Set实现的子接口有HashSet和TreeSet等一般使用HashSet。
9.3 Map接口
Map接口主要使用其HashMap实现类。
HashMap是以键值对来存储的，键不能重复，如果发生重复，新的键会替换就的键。
9.4 Iterator接口
所有实现了Collection接口的容器类都有一个Iterator方法，返回一个实现了Iterator接口的对象。
有以下方法：
- boolean hasNext():判断游标当前位置的下一个位置是否还有元素没有被遍历
- Object next():返回游标当前位置的下一个元素并将游标向下移动一个位置
- void remove():删除游标当前位置的元素,在执行完next后该操作只能执行一次
9.5 Collections工具类
java.util.Collections类提供了对Set、List、Map进行排序、填充、查找的辅助方法。
- void sort(List):排序方法，按照升序排序
- void shuffle(List):对容器的元素随机排列
- void reverse(List):对元素逆序排列
- void fill(List,Object):用一个特定的对象重写整个List容器
- int binarySearch(List,Object):对顺序的List容器，采用折半查找的方法来找到特定对象
10. IO技术
IO流编写格式示例：
public class Chapter01 {
public static void main(String[] args) {
//①声明流
FileInputStream fileInputStream=null;
try {
//②在try...catch中实例化声明的流
fileInputStream=new FileInputStream("D:/test.txt");
StringBuilder stringBuilder=new StringBuilder();
int temp=0; //temp等于-1时，表示已经到了文件结尾，停止读取
//③使用流读写文件
while ((temp=fileInputStream.read())!=-1){
stringBuilder.append((char) temp);
}
System.out.println(stringBuilder);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
//④在fianlly里关闭流，后开先关
try {
//写在finally里即使遇到异常情况也可以关闭流对象
fileInputStream.close();
}catch (IOException e){
e.printStackTrace();
}
}
}
}
10.1 字节流
FileInputStream：通过字节的方式读取文件
FileOutputStream：通过字节的方式写数据到文件
10.2 字符流
字符流以字符为单位进行操作，分别有FileReader、FileWriter
10.3 缓冲流
缓冲流可以提高效率
缓冲字节流：BufferedInputStream、BufferedOutputStream
缓冲字符流：BufferedReader、BufferedWriter
10.4 数组流
数组流是把内存中的“某个字节数组对象”当作数据源
字节数组流:ByteArrayInputStream、ByteArrayOutputStream
10.5 数据流
数据流是把“基本数据类型与字符串类型”作为数据源
数据流：DataInputStream和DataOutputStream
10.6 对象流
对象流是以“对象”为数据源
对象流：ObjectInputStream和ObjectOutputStream
10.7 转换流
转换流实现将字节流转化成字符流
转换流：InputStreamReader、OutputStreamWriter
10.8 序列化与反序列化
将对象序列化后可以用输出流输出到文件
用输入流从文件读入序列化后的对象需要反序列化
要序列化的对象需要实现Serializable接口（空接口起标记作用）
10.9 FileUtils
要用Apache IOUtils和FileUtils类库要下载相关的jar包
11. 多线程
11.1 Java实现线程的方法：
- 继承Thread类或Runnable接口
- 在run()方法里编写线程体（即线程的内容）
- 实例化线程对象，并调用start()方法
示例(继承Thread类)：
//1.通过继承Thread类实现
class TestThread extends Thread{
//2.run（）方法中编写线程体
@Override
public void run() {
for (int i=0;i<10;i++){
System.out.println(this.getName()+":"+i);
}
}
}
public class Chapter01 {
public static void main(String[] args) {
//3.实例化线程类
TestThread testThread=new TestThread();
//4.调用start()方法启动线程
testThread.start();
}
}
示例(继承Runnable接口)：
//1.通过继承Runnable接口实现
class TestThread2 implements Runnable{
//2.run（）方法中编写线程体
@Override
public void run() {
for (int i=0;i<10;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
public class Chapter01 {
public static void main(String[] args) {
//3.实例化Thread类,传入自定义实现Runnable接口的类
Thread thread=new Thread(new TestThread2());
//4.调用start()方法
thread.start();
}
}
11.2 暂停线程的常用方法：
- sleep()方法，休眠一段时间后加入就绪状态
- yield()方法，直接让线程加入就绪状态，让出CPU
11.3 联合线程的方法
调用线程的join()方法
11.5 线程同步避免冲突方法：
- 在方法声明中加入synchronized关键字（缺点影响效率）
- 采用synchronized块
解决死锁方法：思路是避免同一个代码块同时持有两个对象锁
浙公网安备 33010602011771号