二万字的Java学习笔记（复习Java足以）
Posted kitty_Happy
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了二万字的Java学习笔记（复习Java足以）相关的知识，希望对你有一定的参考价值。
✨写在前面
- 💖作者简介：大家好，我是 kitty_Happy。
- 😉正在学习的小白一名，很乐于与大家交流各种技术，共同学习！
- 🐈作者主页：kitty_Happy
- 🎉点赞 ➕ 评论 ➕ 收藏 == 养成习惯😜
- 文章前三章单独链接：4600字的封装、继承，多态笔记（推荐收藏）
- 💬 总结：希望你看完之后，能对你有所帮助，不足请指正！ 🖊
- ✉️ 不要被任何人打乱自己的脚步，因为没有谁会像你一样清楚和在乎自己的梦想。♦
文章目录
🍖1、对象和封装
🍟1.1、构造方法
语法：
[ 访问修饰符 ] 方法名 ( [ 参数列表 ] )
//……省略方法体的代码
-
构造方法的名称必须和类名相同，但是没有返回值类型。在构造方法的定义中参数列表是可选的，因此可以定义无参构造方法，也可以定义带参构造方法。
-
在java中，每一个类都默认自带了一个构造方法叫做缺省构造器，如有没有创建，则系统会自动创建一个默认的构造方法，默认构造方法是没有参数的，而且在方法体中没有代码。（无参构造器）
注意： 当我们创建了构造方法之后，Java自带的无参构造方法就会消失，需要我们自己写出来
🍟1.2、this
this 的三种用法：
1、使用 this 关键字调用成员变量，解决成员变量和局部变量的同名冲突
public Strive(String name)
this.name = name; //成员变量和局部变量同名，必须使用 this 关键字
2、使用 this 关键字调用成员方法
public Strive(String name)
this.name = name;
this.print(); // 调用成员方法
3.使用 this 关键字调用已定义的构造方法
在以下代码中定义了 Strive 类，并定义了两个带参构造方法
public void Strive()
String name;
String sex;
int age;
String dept;
public Strive(String name, String sex)
this.name = name;
this.sex = sex;
public Strive(String name, String sex, int age, String dept)
this(name,sex); //调用已定义的构造方法（调用上面那个构造方法）
this.age = age;
this.dept = dept;
以上使用 this 关键字调用构造方法，并传入局部变量 name 和 sex 作为参数，执行时，首先执行 Strive(String name,String sex) 构造方法，完成对 name 属性和 sex 属性的赋值，然后执行后面的语句实现对 age 属性和 dept 属性的赋值。
🍟1.3、方法重载
🍕1.3.1、方法重载的定义
方法重载指的是同一个类包含两个或两个以上的方法，它们的方法名相同，方法参数个数不同，
方法参数类型不同。成员方法和构造方法都可以进行重载
例如：
System.out.println("good");
System.out.println(true);
System.out.println(100);
这里的方法重载使用的是方法参数类型不同
🍕1.3.2、方法重载的特点
方法重载判断的依据如下：
- 必须在同一个类中
- 方法名相同
- 参数列表 （方法参数的个数或参数类型） 不同
注意： 方法的返回值和方法的访问修饰符不能作为判断方法之间是否构成重载的依据
🍕1.3.3、方法重载的使用和优点
public int Strive(int a,int b)
return a+b;
public double Strive(double a,double b)
return a+b;
public String Strive(String s1,String s2)
return s1+s2;
public static void main(String[] args)
Adder adder = new Adder();
int a = 6,b = 8;
System.out.println(adder.Strive(a,b));
double c = 9 , d = 10.9;
System.out.println(adder.Strive(c,d));
String s1 = "Hello",s2 = "World";
System.out.println(adder.Strive(s1,s2));
- 由以上代码可见，方法重载是对原有方法的一种升级，可以根据参数的不同，采用不同的实现方法，而且不需要编写多个名称，简化了类调用方法的代码
🍟1.4、使用封装重构类的属性和方法
🍕1.3.1、封装的概念
封装是面向对象的三大特性之一，就算将类的状态信息隐藏在类内部，不允许外部程序直接访问，而通过该类提供的方法实现对隐藏信息的操作和访问。
封装反映了事物的相对独立性，有效避免了外部错误对此对象的影响，并且能够给用户由于大意产生的错误操作起到预防作用
- 好处： 封装的好处在于隐藏类的细节，让用户只能通过开发人员规定的方法访问数据，可以方便地加入访问修饰符来限制不合理操作
🍕1.4.2、封装的步骤
实现封装的步骤如下：
1、修改属性的可见性来限制对属性的访问
2、 为每个属性创建一对赋值（setter）方法和取值（getter）方法，用户对这些属性的存取
3、在赋值方法中，可以加入对属性的存取控制语句
🧀1、修改属性的可见性：
使用 private 访问修饰符修饰，private 修饰的属性和方法只能在定义它的类的内部被访问
🧀2、创建赋值和取值方法：
get 方法取值、 set 方法存值
get 方法读、 set 方法改
以上看哪一个能理解，意思一致，代码如下：
private String name; // 私有属性
public void getName() //get方法 读
return name;
public void setName(String name) //set 改
this.name = name;
🧀3、加入对属性的存取控制语句
为了限制不合理赋值，除了设置属性的私有性，还可以在赋值方法中加入对属性的存取控制语句。
假如性别：只有男，女，年龄：0~100 ;代码如下：
private grnder; // 性别
private int age; // 年龄
// 省略get 方法
public void setAge(int age) //控制年龄
if(age < 0 || age > 150)
System.out.println("输入的年龄为:"+age+",该年龄不合法！");
return;
else
this.age = age;
public void setGender(String gender) //控制性别
if(gender.equals("男") || gender.equals("女"))
this.gender = gender;
else
System.out.println("*** 性别不合法 ！***");
🍟1.5、类和类成员的访问控制
1、类和访问修饰符
| 修饰符 | 同一包中 | 非同一包中 |
|---|---|---|
| public | 可以使用 | 可以使用 |
| 默认修饰符 | 可以使用 | 不可以使用 |
省略访问修饰符，就算默认修饰符
2、类成员的访问修饰符
| 修饰符 | 同一类中 | 同一包中 | 子类中 | 外部包 |
|---|---|---|---|---|
| private | 可以使用 | 不可以使用 | 不可以使用 | 不可以使用 |
| 默认修饰符 | 可以使用 | 可以使用 | 不可以使用 | 不可以使用 |
| protected | 可以使用 | 可以使用 | 可以使用 | 不可以使用 |
| public | 可以使用 | 可以使用 | 可以使用 | 可以使用 |
🍟1.6、static 关键字
static 关键字可以修饰类的属性，方法和代码块。使用 static 修饰的属性和方法不再属于具体的某个对象，而属性它所在的类
使用 static 修饰的 属性或方法可以使用 “ 类名 . ” 的方式调用，不需要再消耗资源反复创建对象
使用 static 修饰的方法属于 静态方法，使用类名调用，static 修饰的变量属于静态变量，类加载的时候加载进方法区
🍕1.6.1、用 static 关键字修饰属性和代码块
如下静态代码块：
static
System.out.println("HelloWorld");
static 修饰的是类加载的时候执行，创建对象的时候执行，创建对象的时候应先执行 static静态代码块里面的内容
注意：
- 有多个静态代码块的时候，按照静态代码块的前后顺序执行
- 在方法里不可以定义 static 变量，也就是静态变量不能是局部变量
- 在静态方法中不能直接访问实例变量和实例方法
- 在实例方法中可以直接调用类中定义的静态变量和静态方法
🍖2、继承
🍟2.1、继承的基本概念
继承是面向对象的三大特征之一，继承可以解决编程中代码冗余的问题，是实现代码重用的重要手段之一。
语法：
[ 访问修饰符 ] class <SubClass> extends <SuperClass>
其中，SubClass 被称为子类或派生类，SuperClass 被称为父类或基类。
Java 继承规则如下：
1、可以继承父类中 public 和 protected 修饰的属性和方法，不论子类和父类是否在同一包中。
2、可以继承默认访问修饰符修饰的属性和方法，但是子类和父类必须在同一包中
3、无法继承 private 修饰的属性和方法
4、无法继承父类的构造方法
注意：
在 Java 中只支持单继承，即每个类只能有一个直接父类
🍟2.2、继承的应用
如下：
/**
*动物父类
*/
public class Animal
public void cry()
System.out.println("动物叫。。。。");
/**
* 继承了动物类的小猫类也有 cry() 方法（子类）
*/
public class Cat extends Animal
// 有父类的方法与属性
🍟2.3、Object
Object 类属性超级父类（老祖宗），当一个类没有任何继承的时候，默认继承 Object 类，自带 Object 类里面的 方法与属性
注意：
子类被创建对象的时候必是先执行 Object 类的构造方法，因为构造方法第一行中有隐藏的 super() 调用父类构造方法，最终的父类一定是 Object 类
🍟2.4、继承关系中的方法重写
子类通过继承可以拥有和父类相同的特征和行为，另外，子类也可以定义自己特有的行为，既沿袭了父类的方法名称，又重新实现了父类方法，这就是方法重写。
在子类中可以根据需求对从父类继承的方法进行重写编写，这被称为方法重写或方法覆盖。
方法重写必须遵守以下规则：
- 重写方法和被重写方法必须具有相同的方法名
- 重写方法和被重写方法必须具有相同的参数列表
- 重写方法的返回值类型必须和被重写方法的返回值类型相同或是其子类
- 重写方法不能缩小被重写方法的访问权限
重写的时候可以在方法上面使用注解：
@Override
@Override 是用 Java 注解的方法表示该方法重写了父类方法，可以写也可以不写，在功能实现上没有区别，但是通过 @Override 注解，程序更加方便阅读。另外，编译器也会帮助验证 @Override 下面的方法名是否是父类所有的。如果其不符合方法重写规则，则会报错。
提示：
Java 注解又被称为 Java 标注，是 Java 5 引入的一种注解机制。
🍟2.5、方法重载和方法重写的区别
- 方法重载涉及同一个类中的同名方法，要求方法名相同，参数列表不同，与返回值类型和访问修饰符无关
- 方法重写涉及的是子类和父类之间的同名方法，要求方法名相同，参数列表相同，返回值类型i相同或是其子类
🍟2.6、super关键字
如果想在子类中调用父类的被重写的方法，可以使用 ” super.方法名 “实现
super 关键字代表对当前对象的直接父类对象的默认引用。在子类中可以通过 super 关键字访问父类的成员，包括父类的属性和方法。语法如下：
语法：
访问父类构造方法 ：super(参数)
访问父类属性 / 方法 ：super.< 父类属性 / 方法 >
使用 super 关键字，需要注意以下几点：
- super 关键字必须出现在子类（子类的方法和构造方法）中，而不允许在其他位置。
- 可以访问父类的成员，如父类的属性，方法，构造方法。
- 注意访问权限的限制，如无法通过 super 关键字访问 private 成员。
注意：
1、在构造方法中如果有 this 语句或 super 语句，则只能是第一条语句。
2、在一个构造方法中，不允许同时使用 this 关键字和 super 关键字调用构造方法（否则就有两条第一条语句）。
3、在静态方法中不允许出现 this 关键字或 super 关键字。
4、在实例方法中，this 语句和 super 语句不要求是第一条语句，可以共存。
5、子类构造方法中第一行有隐藏的 super( ) 调用父类构造方法，最终父类一定是 Object 类
🍟2.7、继承关系中的构造方法
在 Java 中，一个类的构造方法在如下两种情况下会被执行：
- 创建该类对象（实例化）
- 创建该类的子类对象（子类的实例化）
子类在实例化时，会首先执行其父类的构造方法，然后才会执行子类的构造方法。
在 Java 语言中，当创建一个对象时，Java 虚拟机（JVM）会按照父类——>子类的顺序执行一系列的构造方法。
子类继承父类时构造方法的调用规则如下：
- 如果在类的构造方法中没有通过 super 关键字显式调用父类地带参构造方法，也没有通过 this 关键字显式调用自身地其他构造方法，则系统会默认先调用父类的无参构造方法。在这种情况下，是否写 “ super( ); ”语句，效果是一样的。
- 如果在子类的构造方法中通过 super 关键字显式地调用了父类地带参构造方法，那么将执行父类相应的构造方法，而不执行父类无参构造方法。
- 如果在子类的构造方法中通过 this 关键字显式地调用了自身地其他构造方法，那么在相应构造方法中遵循以上两条规则。
- 如果存在多级继承关系，则在创建一个子类对象时，以上规则会多次向上更高一级父类应用，直到执行顶级父类 Object 类的无参构造方法为止。
🍖3、多态
面向对象的三大特性为 封装、继承、多态。最后一个特性——多态。它能使同一个操作当作用于不同的对象时，产生不同的执行结果。
使用多态可以提高代码的可维护性和可扩展性
🍟3.1、子类到父类的转换（向上转型）
子类到父类的转换被称为向上转型。（自动类型转换）
语法：
< 父类型 > < 引用变量名 > = new < 子类型 > ( );
Strive strive1 = new s1();
Strive 为父类型 strive1 为引用变量名 s1 为子类型
- 父类型的引用指向子类型的对象
实现多态的三个条件如下：
1、继承的存在（继承是多态的继承，没有继承就没有多态）。
2、子类重写父类的方法（多态下调用子类重写后的方法）。
3、父类引用变量指向子类对象（向上转型）。
🍟3.2、父类到子类的转换（向下转型）
父类到子类的转换被称为向上转型。（强制类型转换）
语法：
< 子类型 > < 引用变量名 > = ( < 子类型 > ) < 父类型的引用变量 >;
Strive strive1 = (Strive)s1;
s1 为 父类型的引用变量，Strive 为子类型，strive1 为引用变量名
🍟3.3、instanceof 运算符
语法：
对象 instanceof 类或接口
- 该运算符用来判断一个对象是否属于一个类或实现了一个接口，结果为 true 或 false。
- 在强制类型转换之前通过 instanceof 运算符检查对象的真实类型，再进行相应的强制类型转换，这样就可以避免类型转换异常，从而提高代码的健壮性。
if(Strive instanceof s1) // 类型判断
Strive strive1 = (Strive)s1;
else
System.out.println("Strive与s1没有关系");
🍟3.4、多态的优势
- 可替换性：多态对已存在的代码具有可替换性
- 可扩充性：多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性，继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。
- 灵活性：在多态的应用中，体现了灵活多样的操作，提高了使用效率。
- 简化性：多态简化了应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出
多态的使用大多体现在实际开发中，多写代码，多用多态，慢慢自然能够体验到多态的灵活性以及多态的重要性
🍖4、三大特性总结
面向对象的三大特性：封装、继承、多态。
- 封装就是声明类的成员变量为私有的，同时提供公有的方法实现对该成员变量的存取操作。
- 继承是软件可重用性的一种表现，新类可以在不增加自身代码的情况下，通过从现有的类中继承其属性和方法充实自身内容，这种现象或行为被称为继承。
- 多态是具有表现多种形态的能力的特征。在程序设计的术语中，它意味着一个特定类型的变量可以引用不同类型的对象，并且能自动地调用引用地对象的方法，也就是根据作用到的不同的对象类型，响应不同的操作。
封装、继承、多态三大特性在Java中非常非常非常重要，一定要统统理解
🍖5、抽象类和接口
🍟5.1、抽象类
顾名思义，抽象类就是抽象出来的类，一般来说，具体类有直接对应的对象，而抽象类没有，它往往表达的是抽象的概念。
例如：
一只猫是具体对象，而猫科动物则是抽象的概念；玉米是具体对象，而作物则是抽象概念。
语法：
< 访问修饰符 > abstract class < 类名 >
abstract 关键字表示该类被定义为抽象类
区别：
抽象类与普通类的最大区别就是：普通类可以被实例化，而抽象类不能被实例化
🍟5.2、抽象方法
当一个类的方法被 abstract 关键字修饰时，该方法被称为抽象方法。
注意：
抽象方法所在的类必须是抽象类，抽象类中可以包含抽象方法，也可以包含普通方法，还可以包含普通类包含的一切成员。
抽象方法：
一个方法被定义为抽象方法，意味着该方法不会有具体的实现（没有方法体），而在抽象类的子类中通过方法重写实现。
语法：
[ 访问修饰符 ] abstract <返回类型> < 方法名 > ( [ 参数列表 ] )
abstract 关键字表示该方法被定义为抽象方法
区别：
抽象方法与普通方法最大的区别是：普通方法有方法体，而抽象方法没有方法体。
public void print() // 普通方法
public abstract void print(); // 抽象方法
总结：
1、在抽象类中，可以没有、有一个或多个抽象方法，甚至可以定义全部方法都是抽象方法。
2、抽象方法只有方法声明，没有方法实现。有抽象方法的类必须声明为抽象类。子类必须重写所有的抽象方法才能实例化；否则子类也必须声明成抽象类
3、抽象类可以有构造方法，其构造方法可以被本类的其他构造方法调用。若此构造方法不是由 private 修饰的，也可以被本类的子类中的构造方法调用。
🍟5.3、final 修饰符
final 是 java 关键字，表示 ”最后的、最终的、不可变的 “。
1、final 修饰的类：
用 final 修饰的类不能再被继承，没有子类
public final class Dog
class Puppy extends Dog // 不能被继承
2、final 修饰类的方法
用 final 修饰的类的方法不能被子类重写
public class Student
public final void print() // 不能被子类重写
System.out.println("记得快乐！");
3、final 修饰的变量
final 修饰的变量叫做常量，如定义成员变量，一定需要初始化，不然报错，如下：
public static final int i = 10;
final 修饰的局部变量只能赋值一次，不然报错
final int i;
i = 10;
i = 11; // 会报错，只能赋值一次
🍟5.3、final 与 abstract 修饰符
abstract：
可以用来修饰类和方法，不能用来修饰属性和构造方法。
final：
final 可以用来修饰类，方法和属性，不能修饰构造方法
🍟5.4、接口
接口类似一套规范，定义统一的标准，可以约束类的行为，使实现接口的类（或结构）在形式上保持一致
🍕5.4.1、定义和实现接口
接口定义：
接口类型的定义语法如下：
[访问修饰符] interface 接口名
// 接口成员
接口实现：
类实现接口的语法如下：
class 类名 implements 接口名
// 类成员
接口中的属性都会自动加上 public static final 修饰，无论是否写了此关键字，接口的属性都是全局静态常量，必须在定义时指定初始值。
int P = 5; // ①
public static final int P = 5; // 效果与 ① 的效果一致
int P; // 没有初始化会报错
接口方法：
在接口中可以定义 抽象方法、默认方法、静态方法，如下：
public interface MyInterface
// 抽象方法
void function1(); // 抽象方法没有方法体，非抽象子类必须重写
// 默认方法
default void function2()
System.out.println("这是一个默认方法");
// 静态方法
static void function3()
System.out.println("这是一个静态方法");
如下实现类：
public class MyClass implements MyInterface
@Override
public void function1() // 重写抽象方法
System.out.println("实现 MyInterface 接口的 function1()!");
public static void main(String[] args)
MyClass myClass = new MyClass();
myClass.function1(); //调用实现类中重写的方法
myClass.function2(); // 调用接口中的默认方法
MyInterface.function3(); // 调用接口中的静态方法
效果如下：
接口本身继承接口：
接口本身也可以继承接口，如下：
[ 访问修饰符 ] interface 接口名 extends 父接口1、父接口2、…
// 常量定义
// 方法定义
实现多个接口：
一个普通类只能继承一个父类，但能同时实现多个接口，也可以同时继承一个父类并实现多个接口。如下：
class 类名 extends 父类名 implements 接口1、接口2…
// 类的成员
注意：
普通类不管同时实现多少接口，必须把接口中的所有抽象方法全部重写。
🍟5.5、面向对象设计原则
在实际开发过程中，遵循以下原则会让代码更具有灵活性，
以上是关于二万字的Java学习笔记（复习Java足以）的主要内容，如果未能解决你的问题，请参考以下文章
30万字的Java自学笔记免费分享啦，并谈谈我的编程自学心得体会
30万字的Java自学笔记免费分享啦，并谈谈我的编程自学心得体会
肝了很久，冰河整理出这份4万字的SpringCloud与SpringCloudAlibaba学习笔记！！
历时三个月，少说有三十多万字的《从零开始学习Java设计模式》小白零基础设计模式入门导读（强烈建议收藏）