【超硬核】Java SE 面向对象基础知识体系 2W超详细,我说的

2.2 基本数据类型

---

byte、short、int、long、float、double、boolean、char；

2.3 引用数据类型

---

String.class SUN提供的；

System.class SUN提供的；

Student.class 程序员自定义的(是一个类，类型，引用数据类型)；

---

3、成员/实例/对象变量、实例（对象）

===================

3.1 对象的基本性质

---

1）类体=属性+方法，属性【存储数据采用变量的形式】；

2）对象又被称为实例，实例变量又被称为对象变量【对象级别的变量】；

3）不创造对象，这个变量的内存空间是不存在的，只有创建了对象，这个变量的内存空间才会被创建；

3.2 成员变量、实例变量、静态变量（类变量）、局部变量

---

1）成员变量：作用范围是整个类，相当于C中的全局变量，定义在方法体和语句块之外，一般定义在类体当中；成员变量包括实例变量和静态变量(类变量)；

成员变量没有手工赋值的话，系统默认值如下：

数据类型 默认值

​

————————————————————————————————————————————————

​

byte，short，int，long 0；

​

float，double   0.0；

​

boolean false；

​

char \U000;

​

引用数据类型       null；

2）实例变量：独立于与方法之外的变量，无static修饰，声明在一个类中，但在方法、构造方法和语句块之外，数值型变量默认值为0，布尔型默认值为false，引用类型默认值为null；

*实例变量不能通过“类名”去访问，必须通过引用；

*实例变量在堆内存的java对象内存中存储；

3）静态变量(类变量)：独立于方法之外的变量，用static修饰，默认值与实例变量相似，一个类中只有一份，属于对象共有，存储在(方法区内存)静态存储区，经常被声明为常量，调用一般是类名.静态变量名，也可以用对象名.静态变量名调用；

public static String level = "SSS"; *//成员变量、静态变量(类变量)*

4）局部变量：类的方法中的变量，访问修饰符不能用于局部变量，声明在方法、构造方法或语句块中，在栈上分配，无默认值，必须经初始化；

---

4、对象的创建和使用

==========

4.1 对象和引用的定义

---

new运算符在栈内存中开辟的内存空间称为对象；

引用是一个变量，只不过这个变量中保存了另一个java对象的内存地址；

1）与C语言中的指针不同，指针可以指向内存空间的任意一块地址

2）java中无指针，不能直接操作堆内存，只能通过“引用”访问堆内存中对象的实例变量(保证了java语言的安全性）

4.2 对象的创建

---

1）通过一个类可以实例化多个对象，实例化的语法：new 类名（）；

2）new是java语言中的一个运算符，其作用是创建对象，在JVM堆内存中开辟新的内存空间；

3)将对象产生关系，协助起来，形成一个系统；

int i = 10;

int 是一个基本数据类型；i是一个变量名；10是int类型的字面值；

Student s = new Student( );

Student 是一个引用数据类型；s是局部变量【在栈内存中存储】表示引用；**new Student（）**是创建一个学生对象；

4.3 JVM三大内存

---

方法区内存：在类的加载的时候，class字节码代码片段会被加载到该内存空间；

栈内存（局部变量）：方法代码片段在执行的时候会给该方法分配内存空间，在栈内存中压栈；

堆内存：new的对象在堆内存中存储；

4.4 对象的访问

---

访问实例变量的语法格式：

读取数据：引用.变量名;

修改数据：引用.变量名 = 值;

4.5 实例

---

//用户类

public class User{

int no；//基本数据类型 实例变量

String name；//引用数据类型 实例变量

Address addr；//引用数据类型 实例变量

}

//家庭住址类

public class Address{

String city；//引用数据类型 实例变量 city是一个引用：保存内存地址的一个变量，该变量保存内存地址指向了堆内存；

String street；

String zipcode；

}

//测试类1

public class helloworld{

public static void main(String[] args){

User u = new User();

System.out.println(u.no);

System.out.println(u.name);

System.out.println(u.addr);

u.no = 110;

u.name = “jack”;

u.addr = new Address();

}

}

//测试类2

public class helloworld{

public static void main(String[] args){

User u = new User();

Address a = new Address();

u.addr = a;

System.out.println(u.addr.city);

a.city = “天津”;

System.out.println(u.addr.city);

}

}

4.6 夫妻类

---

//丈夫类

public class Wife{

String name;

Husband h;//丈夫对象当中含妻子引用

}

//妻子类

public class Husband{

String name;

Wife w;//妻子对象当中还有丈夫引用

}

public class Code{

public static void main(String[] args){

//创建一个丈夫对象

Husband huang = new Husband();

huang.name = “黄晓明”;

//创建一个妻子对象

Wife baby = new Wife();

baby.name = “baby”;

//结婚【通过丈夫找到妻子，也可以通过妻子找到丈夫】

huang.w = baby;

baby.h = huang;

//得到黄晓明的妻子的名字

System.out.println(huang.name + “妻子的名字是” + huang.w);

}

}

4.7     JVM

---

4.7.1 内存区

当中变化最频繁的是栈内存，最先有数据的是方法去内存，垃圾回收器主要针对的是堆内存；

4.7.2 垃圾回收器【自动垃圾回收机制、GC机制】

什么时候考虑将某个java对象的内存回收呢？

1）当栈内存当中java对象称为垃圾数据的时候，会被垃圾回收器回收；

2）什么时候堆内存的java的对象会变成垃圾呢？ -没有更多的引用指向它的时候；

-这个对象无法被访问，因为访问对象只能通过引用的方式访问；

4.8 空指针异常

---

public class Code{

public static void main(String[] args){

Customer c = new Customer();

System.out.println(c.id);

c=null;

//以下程序编译可以通过，因为符合语法， //运行出现空指针异常

//空引用访问“实例”相关的数据一定会出现空指针异常

//java.lang.NullPointerException

System.out.println(c.id);

}

}

4.9 关联关系和继承关系

---

关联关系：A has a B【A对象中含有B对象的引用】；

继承关系：A is a B【关系更加紧密】；

---

5、封装

====

5.1 封装的好处

---

1）封装之后对于那个事物来说，看不到这个事物比较复杂的那一面，只能看到该事物简单的那一面，复杂性封装，对外提供简单的操作入口；

2）封装之后才会形成真正的"对象"，真正的"独立体"；

3）封装之后意味着以后的程序可以重复使用，并且这个事物适应性比较强，在任何场所都能够使用；

4）封装之后，对于事物本身提高了安全性；

5.2 如何封装

---

1）属性私有化

使用private关键字进行修饰，修饰的所有数据只能在本类中访问；

2） 对外提供简单的操作入口(两个公开的方法)

-调用set方法：修改属性；

-调用get方法：读取属性；

3）set方法的命名规范

public void setAge(int a){

//编写业务逻辑代码进行安全控制 if（）

age = a;

}

由于java有就近原则，以下代码Error

public void setAge(int age){

age = age;

}//这里并没有给age属性赋值，这里的age都是局部变量age

4）get方法的命名规范

public int getAge(){

//编写业务逻辑代码进行安全控制 if（）

return age;

}

而在eclipse中get和set方法不用写，直接按下面操作自动生成get，set方法

单击右键—>Source—>Generate Getters and Setters

5.3 封装后如何访问

---

调用方法：

修改：user.setAge(-100)；

读取：user.getAge();

注意：不能通过"类型.变量名"访问，已经封装在类中，外部无法访问，只能通过方法；

---

6、构造方法

======

6.1 定义

---

构造方法又被称为构造函数/构造器/Constructor

6.2 构造方法的语法结构

---

[修饰符列表] 构造方法名 （形式参数列表）{

​

构造方法体；  

​

}

与普通方法的语法结构对比：

[修饰符列表] 返回值类型 方法名（形式参数列表）{

​

    方法体；

​

}

注意：

1）"返回值类型"不需要指定，也不用写void；

写上void就变成了普通方法了；

2）构造方法名必须与类名相同；

6.3 构造方法的调用

---

1）普通方法的调用：

方法修饰符有static时：类名.方法名（实参列表）；

方法修饰符没有static时：引用.方法名（实参列表）；（需要先创建对象）

2）构造方法的调用： new 构造方法名（实参列表）；

3）构造方法执行之后有返回值，且返回值类型为构造方法所在类的类型（他本身），所以语法结构中不用写返回值类型，构造方法执行之后java程序自动返回值；

4）当一个类中没用定义任何构造方法的话，系统默认给该类提供一个无参数的构造方法，这个构造方法被称为缺省构造器；

5）当一个类显示的将构造方法定义出来了，那么系统不再默认提供的缺省构造器了，建议开发中手动的为当前类提供无参数的构造方法；

6）构造方法支持重载机制，在一个类中编写多个构造方法，这多个构造方法显然已经构成方法重载机制；

public class Code{

public static void main(String[] args){

User u1 = new User(“Jack”);

User u2 = new User(10);

}

}

​

public User(int i){

System.out.println(“带有int参数类型的构造器”)

}

public User(String name){

System.out.println(“带有String参数类型的构造器”)

}

6.4 方法有无static方法的调用

---

方法有static修饰时，调用方法时不需要new对象，直接通过方法名（实参）/类名.方法名（实参）调用；

public class Code{

public static void main(String[] args){

Code.dosome();

dosome;

}

}

public ststic void dosome(){

System.out.println(“do some”);

}

方法没有static修饰时，调用方法时需要new对象；

public class Code{

public static void main(String[] args){

Code t = new Code();

t.dosome;

}

}

​

public void dosome(){

System.out.println(“do some”);

}

6.5 构造方法的作用

---

1）创建对象；

2）初始化实例变量的内存空间，赋值；

注意： 实例变量的系统默认赋值不是在类加载的时候完成赋值的，类加载的时候只将代码片段加载到了方法区内存，而实例变量的初始化是在创建对象之后（构造方法完成之后）完成初始化的

6.6 自动构造方法的快捷方式

---

单击右键—>Source—>Generate Constructor using Fields…

6.7 面向对象的封装以及构造方法的实例

---

public class helloworld{

public static void main(String[] args){

Bank b = new Bank(“Jack”,1000);

System.out.println(“账号名字为” + b.getName());

System.out.println(“账号余额为” + b.getMoney());

Bank a = new Bank();

System.out.println(“账号名字为” + a.getName());

System.out.println(“账号余额为” + a.getMoney());

}

}

class Bank{

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getMoney() {

return money;

}

public void setMoney(int money) {

this.money = money;

}

private String name;

private int money;

//无参数的构造器

public Bank(){

}

//有参数的构造器

public Bank (String s,int d) {

name = s;

money = d;

}

}

---

7、this关键字

=========

7.1 this关键字的定义和性质

---

1）this是一个关键字 / 引用 / 变量，this变量中保存了内存地址表示自身，this存储在JVM堆内存java对象内；

2）创建100个java对象，每一个对象都有this，也就是说有100个不同的this；

3）this可以出现在“实例方法”当中，this指向当前正在指向这个动作的对象。【this代表当前对象】；

4）this在多数情况下都是可以省略不写的；

5）this在区分局部变量和实例变量的时候，"this."不能省；

public void setName(String name) {

this.name = name;

}

//“=”前面的this.name是实例变量

//“=”前面的name是局部变量，是形式参数

6）this不能使用在带有static的方法当中；

7.2 实例方法与实例变量

---

7.2.1 实例方法的访问（不带static的方法）

public class helloworld {

public static void main(String[] args) {

// 创建Customer对象

Customer c1 = new Customer();

c1.name = “zhangshan”;

// c1购物

c1.shopping();

​

// 创建Customer对象

Customer c2 = new Customer();

c2.name = “lisi”;

// c2购物

c2.shopping();

}

}

​

class Customer {

// 姓名

String name;

​

// 构造方法

public Customer() {

}

//实例方法

public void shopping(){

//当张三在购物的时候输出"张三在购物"

//当李四在购物的时候输出"李四在购物"

System.out.println(this.name + “在购物”);

}

}

7.2.2 实例变量的访问（不带static的变量）

public class helloworld {

public static void main(String[] args) {

//访问"当前对象"的num属性

//System.out.println(num); //编译错误（因为num是一个实例变量，需要"引用."的方式访问）

//如何访问num?

//创建一个对象

ThisTest tt = new ThisTest();

System.out.println(tt.num);

}

}

​

class ThisTest{

//实例变量

int num = 10;

}

7.3 静态方法

---

1）静态方法（带有static的方法）访问的时候采用 类名.方法名，不能用this；

2）静态方法中不能"直接"访问实例变量和实例方法；（实例变量和实例方法都需要对象的存在）；

3）静态方法中没有this，也就是说"当前对象"不存在，自然也无法访问当前对象的实例变量和实例方法（this代表的是当前正在执行这个动作的对象）；

4）静态方法，既可以采用类名的方式访问，也可以采用应用的方式访问，但是即使采用引用的方式访问，实际上执行的时候和引用指向的对象无关，还是默认成“类名.”的方式访问，且会产生警告，但不会产生空指针异常；

7.4 特例：实例方法中实例方法的访问

---

实例方法和静态方法的访问的比较

public class ThisTest{

public static void main(String[] args){

//ThisTest.doSome();

//编译错误（实例方法必须先创建对象，通过引用.的方式访问）如下：

ThisTest tt = new ThisTest();

tt.run();

doSome();//带有static的方法，可以通过类名.的方式直接访问

}

public static void doSome(){

System.out.println(“do some!”);

}

public void doOther(){

System.out.println(“do other”);

}

//特例：实例方法中实例方法的访问

public void run(){

System.out.println(“run execute!”);

doOther();//this.doOther

//这里可以直接写“doOther();”由于是通过run（）来访问到doOther的，此时this就是访问run（）时的对象

}

}

7.5 实例方法和实例变量的定义和访问的比较

---

不带有static关键字的方法被称为"实例方法"；

不带有static关键字的变量被称为"实例变量"；

public class ThisTest{

public static void main(String[] args){

//编译错误

/*System.out.println(name);

doSome();

System.out.println(this.name);

this.doSome();*/

//编译通过

ThisTest tt = new ThisTest();

System.out.println(tt.name);

tt.doSome();

}

//实例变量

String name;

//实例方法

public void doSome(){

System.out.println(“do some!”);

}

}

7.6 this的作用领域

---

1）可以使用在实例方法中，代表当前对象【语法格式：this】

2）可以使用在构造方法中，通过当前的构造方法调用其他的构造方法【语法格式：this（实参）】；

3）this（）这种语法只能出现在构造方法的第一行；

使用在构造方法中，通过当前的构造方法调用其他的构造方法的代码如下：

public class helloworld {

public static void main(String[] args) {

Date d = new Date();

System.out.println(d.getYear() + “-” +  d.getMonth() + “-” + d.getDay());

Date a = new Date(2021,1,3);

System.out.println(a.getYear() + “-” +  d.getMonth() + “-” + d.getDay());

}

}

​

class Date{

private int year;

private int month;

private int day;

public Date(int year, int month, int day) {

this.year = year;

this.month = month;

this.day = day;

}

public Date() {

//需求：当程序员调用以下无参数的构造方法的时候，默认创建日期为1970.1.1

/*this.year = 1970;

this.month = 1;

this.day = 1;*/

//以上代码可以通过调用另一个构造方法来完成

//但前提是不能通过创新新的对象。以下代码表示创新了一个新的对象

//new Date(1970.1.1);

//需要采用以下的语法来完成构造方法的调用

this(1970,1,1);

}

public int getYear() {

return year;

}

​

public void setYear(int year) {

this.year = year;

}

​

public int getMonth() {

return month;

}

​

public void setMonth(int month) {

this.month = month;

}

​

public int getDay() {

return day;

}

​

public void setDay(int day) {

this.day = day;

}

​

}

7.7 两种方法调用 以及 实例变量的访问 的完整/省略写法

---

public class Test{

//没有static的变量

int i = 10;

//带有static的方法

public static void doSome() {

System.out.println(“do some!”);

}

//没有static的方法

public void doOther() {

System.out.println(“do other!”);

}

//带有static的方法

public static void method1() {

//调用doSOme(带有static的方法)

//完整方法的调用

Test.doSome();

//省略方法的调用

doSome();

//调用doOther(没有static的方法)

//完整方法的调用

Test t = new Test();

t.doOther();

//省略方法的调用

//无

//访问i(实例参数)

//完整方法的调用

System.out.println(t.i);

//省略方法的调用

//无

}

//没有static的方法

public void method2() {

//调用doSOme(带有static的方法)

//完整方法的调用

Test.doSome();

//省略方法的调用

doSome();//this doSome();

//调用doOther(没有static的方法)

//完整方法的调用

this.doOther();//调用的doOther中无static，且当前方法中也无static，当前方法有this，所以直接引用.即this.doOther()

//省略方法的调用

doOther();

//访问i(实例参数)

//完整方法的调用

System.out.println(this.i);

//省略方法的调用

System.out.println(i);

}

//主方法

public static void main(String[] args) {

//要求在这里编写程序调用method1(带有static的方法)

//完整方法的调用

Test.method1();

//省略方法的调用

method1();

//要求在这里编写程序调用method2(没有static的方法)

//完整方法的调用

Test t = new Test();

t.method2();

//省略方法的调用
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

学习分享，共勉

这里是小编拿到的学习资源，其中包括“中高级Java开发面试高频考点题笔记300道.pdf”和“Java核心知识体系笔记.pdf”文件分享，内容丰富，囊括了JVM、锁、并发、Java反射、Spring原理、微服务、Zookeeper、数据库、数据结构等大量知识点。同时还有Java进阶学习的知识笔记脑图（内含大量学习笔记）！

资料整理不易，读者朋友可以转发分享下！

Java核心知识体系笔记.pdf

中高级Java开发面试高频考点题笔记300道.pdf

架构进阶面试专题及架构学习笔记脑图

Java架构进阶学习视频分享
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
doOther();

//访问i(实例参数)

//完整方法的调用

System.out.println(this.i);

//省略方法的调用

System.out.println(i);

}

//主方法

public static void main(String[] args) {

//要求在这里编写程序调用method1(带有static的方法)

//完整方法的调用

Test.method1();

//省略方法的调用

method1();

//要求在这里编写程序调用method2(没有static的方法)

//完整方法的调用

Test t = new Test();

t.method2();

//省略方法的调用
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-Le96dqRN-1712733835048)]

[外链图片转存中…(img-htj0amau-1712733835049)]

[外链图片转存中…(img-bCTmH3Dy-1712733835049)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

学习分享，共勉

这里是小编拿到的学习资源，其中包括“中高级Java开发面试高频考点题笔记300道.pdf”和“Java核心知识体系笔记.pdf”文件分享，内容丰富，囊括了JVM、锁、并发、Java反射、Spring原理、微服务、Zookeeper、数据库、数据结构等大量知识点。同时还有Java进阶学习的知识笔记脑图（内含大量学习笔记）！

资料整理不易，读者朋友可以转发分享下！

Java核心知识体系笔记.pdf

[外链图片转存中…(img-NMvIzfFx-1712733835050)]

中高级Java开发面试高频考点题笔记300道.pdf

[外链图片转存中…(img-cTzOOLhM-1712733835050)]

架构进阶面试专题及架构学习笔记脑图

[外链图片转存中…(img-1BvCmCB7-1712733835051)]

Java架构进阶学习视频分享
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！