JAVA学习开发(基础篇)

JAVA(基础篇)

学习路径

第一阶段：基础篇

第二阶段：数据库

第三阶段：框架

---

Java 基础语法

• 面向对象——封装、继承、多态
• 数组
• 字符串
• 集合框架
• IO
• 反射
• 注解
• 网络编程
• 并发编程

---

基础语法

1. ArrayList 集合
2. JavaBeen
3. 构造方法

---

ArrayList 集合

1. 创建对象
2. 成员方法
3. 遍历

---

1. 创建对象(泛型)

ArrayList<String> list = new Arraylist<>();

2. 成员方法

1. 删除元素：

   • list.remove(序号)
   • list.remove(指定元素)

2. 修改元素

   • set(下标, “修改成的东西”)

   • 修改后，返回被覆盖的数

3. 查询元素

   • list.get(下标)

3. 遍历

list.size()

• 判断长度

list.for i

利用查询实现数组的遍历

---

JavaBeen

1. 私有化成员变量
2. 空参构造方法
3. 带参数构造方法
4. get/set方法

---

构造方法

​ 作用

• 创建对象,并为其初始化
• 增加代码可读性

成员变量

• 写在类里面的属性

成员方法

• 写在类里面的方法

---

面向对象

1. 封装
2. 继承
3. 多态

---

封装

1. 什么是封装
2. 为什么需要封装
3. 关键字
4. 静态变量

---

1. 什么是封装

• 封装是实现面向对象程序设计的第一步，封装就是将数据或函数等集合在一个个的单元中（我们称之为类）被封装的对象通常被称为抽象数据类型
• 将零散的数据装进一个整体

属性

• 是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。
• 对象代表什么,就得封装对应的数据,并提供数据对应的行为
• 只看是谁的属性，不看是谁的行为

例子

人关门：关门应该写在门类里面

画园：画园在园内

2. 为什么要封装

• 封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问

作用

保护或者防止代码（数据）被我们无意中破坏。在面向对象程序设计中数据被看作是一个中心的元素并且和使用它的函数结合的很密切，从而保护它不被其它的函数意外的修改

2. 关键字

Private 关键字

• 安全性

• 只能在自己类里面使用，并需要提供Set和Get方法

This 关键字

• 就近原则

this.变量名：相当于指向最开始的成员变量

static关键字

方便在没有创建对象的情况下进行调用(方法/变量)

3. 静态变量

静态方法

用法

• 多用在测试类和工具类中

---

继承

1. 什么是继承
2. 为什么需要继承
3. 继承的用法和属性
4. This 和 Super 关键字
5. 方法重写

---

1. 什么是继承

概念

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

2. 为什么需要继承

1. 提高代码的重用性。
2. 优化代码，方便修改。
3. 类与类之间产生了关系，是多态的前提。

3. 继承的用法和属性

用法

public class 子类 extends 父类{}

属性

• 子类只能单继承,不能多继承,但可以多层继承
• 子类只能访问父类中非私有的成员

有哪些是子类不能继承的

1. 私有化的，即用private修饰的成员变量和成员方法。
2. 构造方法。
3. 子类与父类不在同一个包中，父类使用默认访问权限的成员变量和成员方法

成员变量的访问特点

就近原则

• 逐级往上
• 局部 =>本类=>父类

构造方法的访问特点

• 在子类构造方法时,有默认添加的super();
• 默认先访问父类中无参的构造方法,再执行自己
• 如果想要方法 中父类有参构造,必须手动书写

4. This和Super

用法

调用本类中的同名属性

this.name

在需要默认值的时候可以用this()来访问本类构方法

调用父类的同名属性

super.name

5. 方法重写

什么是重写

• 重写也称覆盖，是在继承关系下，子类对父类方法代码的修改。
• 当子类出现和父类中一样的方法,则称这个方法是重写的方法

为什么要重写

（1）父类已具有某个功能的方法，子类假如有相同功能的方法，使用重写的方式更加便利，不会造成子类既继承得到了父类的这个功能，又自己拥有一个同样的功能而方法名却不一样的尴尬境地。
（2）继承是多态的前提，重写方法是为了多态的扩展性

什么时候重写

当父类方法不能满足子类现在的需求时,需要方法重写

六种不能重写的情况

1. 访问权限
   • public>protected>friendly
   • 重写后的访问权限只能大于等于父类
2. static
   • 父子类均不能用static修饰
3. 父类方法被final修饰
4. 返回值类型
   （1）基本数据类型：父子类相同
   （2）引用类型：父子类相同仍是父子关系的返回值类型
5. 方法名
6. 参数列表不同

---

多态

1. 什么是多态
2. 为什么需要多态
3. 多态的优势和弊端
4. 调用成员的特点
5. 引用数据类型的强制转换

---

1. 什么是多态

• 对象的多种形态

表现形式

父类类型 对象名称 = 子类对象

多态的前提

• 有继承或实现(接口)关系
• 有父类引用指向子类对象
• 有方法重写

2. 为什么要使用多态?

• 使用父类型作为参数,可以接收所有子类对象
• 体现多态的扩展性与便利

3. 多态的优势和弊端

1. 优势

   • 便于扩展和维护(当业务逻辑发生改变时,无需修改代码)

2. 弊端

   • 不能使用子类的特有功能

4. 调用成员的特点

• 变量调用:编译看左边,运行也看左边(即父类中变量的值)
• 方法调用:编译看左边,运行看右边(即子类方法)

5. 强制转换

为什么需要强制转换

为了强行使用子类的特有功能

能解决什么问题

• 将对象转换成真正的子类类型,从而调用子类独有功能
• 转换类型与真实对象类型不一致会报错
• 转换时用instanceof关键字进行判断(JDK14新特性)

怎么使用

if(a instanceof Dog){
    //强制转换
    Dog d = (Dog)a
    方法
}

关于JDK14

​ 将判断和强转合并为同一个(instanceof)

if(a instanceof Dog d){
    方法
}

---

细节性知识点

---

包和final

1. 包的作用
2. 包名书写的规则
3. 什么是全类名
4. 什么时候需要导包,什么时候不需要导包

---

1. 包的作用

   包是一个用来管理不同功能的Java类的文件夹,以方便后期维护

2. 需要注意

   • 见名知意

3. 全类名

   包名 + 类名

4. 关于什么时候需要导包

• 使用同一个包中的类时,不需要导包

• 使用java. Lang包中的类的时候,不需要导包

• 其余情况则需要导包

• 如果同时使用两个包中的同名类,需要用全类名

---

Final

所需知识点

1.为什么需要Final

---

基础解释

• 修饰方法
  • 表明方法是最终方法,不能被重写
• 修饰类
  • 表明该类最最终类,不能被继承
• 修饰变量
  • 叫做常量,只能被赋值一次

1. 什么时候使用?

当你制定规则,而不希望别人更改

---

权限修饰符

1. 什么是权限修饰符
2. 权限修饰符的分类
3. 使用规则

---

1. 权限修饰符

• 是用来控制一个成员能够被访问的范围的
• 可以修饰成员变量,方法,构造方法,内部类
• private<默认<protected<public

2. 分类

修饰符	同一个包	同一个包中其它类	不同包下的子类	不同包下的无关类
private	V
空着不写	V	V
protected	V	V	V
public	V	V	V	V

3. 规则

实际开发中,一般只用private和public

• 成员变量私有
• 方法公开

---

代码块

1. 局部代码块
2. 构造代码块
3. 静态代码块(重要)

---

1. 局部代码块

提前结束变量的生命周期(淘汰)

2. 构造代码块

抽取构造方法中的重复代码(不够灵活)

3. 静态代码块

• 数据的初始化(只会出现一次)

应用场景

在类加载的时候,做一些数据初始化的时候使用

---

抽象类和抽象方法

1. 什么是抽象类
2. 为什么使用抽象
3. 注意事项

---

1. 什么是抽象类

抽象类

• 如果一个类中存在抽象方法,那么该类就必须声明为抽象类

定义格式

public abstract class类名{}

个人理解

• 不清楚底下具体会有哪些方法,就先用抽象方法去预留空间,写具体方法时再重写(啥也没写,等着写)

抽象方法

• 将共性的行为(方法)抽取到父类之后,由于每一个子类执行内容不一样.所以在父类不能确定具体的方法体

定义格式

public abstract 返回值类型 方法名(参数列表)

2. 为什么需要使用

在写一个项目时,强制别人使用你这个的方法名去进行重写,使可读性增加

2. 注意事项

• 抽象类不能创建对象
• 抽象类中可以没有抽象方法,有抽象方法的类一定是抽象类
• 可以拥有构造方法
• 抽象类的子类(处理方式)
  • 要么重写抽象类中的所有抽象方法
  • 要么是抽象类

---

接口

1. 什么是接口
2. 为什么需要接口
3. 如何定义和使用
4. 它的特点
5. 接口和类的关系
6. 小扩展

---

1. 什么是接口

• 接口只是实现多态的另一种手段
• 它是一种标准,一种规则,一系列抽象方法的集合,来定制规则,展现多态
• 一种对行为的抽象

个人理解

• 接口就是写好一堆东西,然后让类去调用这些方法(写好了等着用)

2. 为什么?

• 我们需要一种规则去创造价值

3. 如何定义和使用

• 使用interface来定义

public interface 接口名{}

• 接口不能实例化
• 接口和类是实现关系,通过implements关键字表示

public class 类名 implements 接口名{}

• 接口的子类(实现类)
  - 重写接口中的所有抽象方法
  - 变成抽象类

4. 成员的特点

• 成员变量
  • 默认修饰符：public static final
• 构造方法
  • 无
• 成员方法
  • JDK 7 以前:只能定义抽象方法
  • JDK 8 : 接口中可以定义有方法
  • JDK 9 : 接口中可以定义私有方法

5. 接口和类的关系

1. 类和类的关系
2. 类和接口的关系
3. 接口和接口的关系

---

1. 类和类的关系

继承关系,只能单继承,不能多继承,但是可以多层继承

2. 类和接口的关系

实现关系可以单实现,也可以多实现,还可以在继承一个类的同时实现多个接口

3, 接口和接口的关系

继承关系,可以单继承,也可以多继承

6. 小扩展

• 接口的应用
• 适配器设计模式

---

接口的应用

1. 接口代表规则,是行为的抽象.想要哪个类拥有一个行为,就让这个类实现对应的接口就行
2. 当一个方法的参数是接口时,可以传递接口所有实现类的对象,这种方法称为接口多态

适配器设计模式

什么是适配器设置模式

设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。

用处

解决接口与接口实现类的矛盾问题(过滤)

什么时候用

当一个接口中抽象方法过多，但是我只要使用其中一部分的时候，就可以适配器设计模式

用法

编写中间类XXXAdapter，实现对应的接口对接口中的抽象方法进行空实现

让真正的实现类继承中间类，并重写需要用的方法

为了避免其他类创建适配器类的对象，中间的适配器类用abstract进行修饰