动作---->一个类的方法（描述对象的动作信息）；
注意:
状态和动作当具体到某个对象上之后，发现最终的结果可能不一样；
对象和对象之间有共同的特征，但是具体到对象之后有数据的差异。
1.2 面向过程和面向对象的区别
1.2.1 面向过程：
主要关注点是：实现的具体过程，因果关系【集成显卡的开发思路】
*优点：
对于业务逻辑比较简单的程序，可以达到快速开发，前期投入成本较低；
*缺点：
采用面向过程的开发很难解决非常复杂的业务逻辑，另外面向过程的方式导致软件元素之间的”耦合度“非常高，只要其中一环出问题，整个系统受到影响，导致最终的软件”扩展力“差。另外由于没有独立体的概念，所以无法达到组件复用。
1.2.2 面向对象：
主要关注点是：主要关注对象}【独立体】能完成哪些功能。【独立显卡的开发思路】
*优点：
耦合度低，扩展力强。更容易解决现实世界当中更复杂的业务逻辑。组合复用性强。
*缺点：
前期投入成本高，需要进行独立体的抽取，大量的系统分析和设计。
-C语言是纯面向过程的、C++半面向对象、Java纯面向对象
2、类的定义
======
2.1 语法结构
[修饰符列表] class 类名{
}
String不属于基本数据类型，是一个字符串类型，也是一个引用类型；
引用数据类型还包括：类，接口，数组；
String是SUN在JavaSE中提供的字符串类型；
String.class字节码文件；
重点：
1、属性通常是采用一个变量的形式来完成定义的；
2、在类体当中，方法体之外定义的变量被称为"成员变量"，成员变量没有赋值，系统赋默认值：一切向0看齐；
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();
//省略方法的调用
//无
}
}
8、static关键字
===========
8.1 static关键字的定义和性质
1）static翻译为"静态的"；
2）static修饰的方法是静态方法，static修饰的变量是静态变量；
3）使用static修饰的元素都称为静态的，都可以用"类名."的方式访问，当然也可以用"引用."的方式访问【但不建议】
4）采用"引用."的方式访问的时候，即使引用是null，也不会出现空指针异常，因为访问静态数据不需要对象的存在；
8.2 实例变量与静态变量
8.2.1 实例变量
什么时候成员变量声明为实例变量呢？
–所有对象都有这个属性，但是这个属性的值会随着对象的变化而变化【不同对象的这个属性具体值不同】
–实例变量在构造方法进行的时候初始化，存在堆内存中
以下列例子说明：
public class helloworld {
public static void main(String[] args) {
Chinese zhangsan = new Chinese(“1”,“zhangsan”,“Chinese”);
System.out.println(zhangsan.country);
}
}
class Chinese{
String id;
String name;
String country;
public Chinese(String id, String name, String country) {
this.id = id;
this.name = name;
this.country = country;
}
}
8.2.2 静态变量
什么时候成员变量声明为实例变量呢？
–所有对象都有这个属性，并且所有对象的这个属性的值是一样的，建议定义为静态变量，节省内存的开销
**静态变量在类加载的时候初始化，内存在方法区中开辟。**访问的时候不需要创建对象，直接使用"类名.静态变量名"的方式访问；
补充：
-
局部变量存储在栈内存当中；
-
实例变量在构造方法进行的时候初始化，存在堆内存中
以下列例子说明：
public class helloworld {
public static void main(String[] args) {
Chinese zhangsan = new Chinese(“1”,“zhangsan”);
System.out.println(zhangsan.country);
System.out.println(Chinese.country);
zhangsan = null;
System.out.println(zhangsan.country);
}
}
class Chinese{
String id;
String name;
static String country = “chinese”;
public Chinese(String id, String name) {
this.id = id;
this.name = name;
}
}
输出结果为三个Chinese；
1）所有静态的数据都是可以采用"类名.“，也可以采用"引用.”，但是建议采用类名.的方式访问；
2）采用"引用."的方式访问时，即使是null，也不会出现空指针异常，因为访问静态变量的时候不需要对象的存在；
8.3 静态代码块
1）语法格式：
static{
//java语句
}
2）静态代码块在类加载时执行，并且执行一次；
3）静态代码块在一个类中可以编写多个，并且遵循自上而下的顺序依次执行；
4）静态代码块可以用在项目中要求在类加载的时刻/时机执行代码完成日志的记录，那么这段记录日志的代码就可以编写在静态代码块当中，完成日志记录；
5）静态代码块是java为程序员准备一个特殊的时刻，这个时刻被称为类加载时刻，若希望在此刻执行一段特殊的程序，这段代码可以放到静态代码块当中；
public class StaticTest{
static{
System.out.println(“类加载—>1”);
}
static{
System.out.println(“类加载—>2”);
}
}
8.4 *实例语句块 / 代码块
1）实例代码块可以编写多个，也是遵循自上而下的顺序依次执行；
2）实例代码块在构造方法执行之前执行，构造方法执行一次，实例代码块对应执行一次；
3）实例代码块也是java语言为程序员准备一个特殊的时机，这个时机被称为：对象初始化时机；
public class helloworld{
public class Test{
//构造函数
public Test(){
System.out.println(“Test类的缺省构造器执行”);
}
}
//实例代码块
{
System.out.println(1);
}
//实例代码块
{
System.out.println(2);
}
public static void main(String[] args){
System.out.println(“main begin”);
new helloworld();
}
}
8.5 static总结
public static void main(String[] args)
8.5.1 对java语句的解读
1）public代表公开的，在任何位置都可以访问；
2）static表示静态的，使用"类名."的方式访问，不需要创建对象
3）void表示main方法执行结束之后不返回任何值；
4）(String[] args)是参数列表；
8.5.2 什么时候定义为静态的？
1）方法描述的是动作，当所有的对象执行这个动作的时候，最终产生影响是一样的，那么这个动作已经不再属于某一个对象动作了，可以将这个动作提升为类级别的动作，模板级别的对象；
2）静态方法中无法直接访问实例变量和实例方法；
3）大多数方法都定义为实例方法，一般一个行为或一个动作在发生的时候都需要对象的参与而大多数“工具类”当中的方法都是静态的，因为工具类就是方便编程的，为了方便方法的调用，自然不需要new对象是最好的；
9、继承
====
1）继承是面向对象的三大特征之一，三大特征分别是：封装、继承、多态；
2）继承"基本"的作用是，代码复用。最重要的作用是：有了继承之后才有的"方法的覆盖"和"多态机制"；
3）继承语法格式：
[修饰符列表] class 类名 extends 父类名字{
类名 = 属性 + 方法;
}
4）java语言当中的继承只有单继承，一个类不能同时继承很多类，只能继承一个类。在C++中支持多继承；
5）关于继承中的一些术语：
B类继承A类，其中：
A类称为：父类、基类、超类、superclass；
B类称为：子类、派生类、subclass；
6）java语言中能继承父类的哪些数据？
-
私有的不支持继承；
-
构造方法不支持继承；
-
其他数据都有被继承；
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）
写在最后
可能有人会问我为什么愿意去花时间帮助大家实现求职梦想，因为我一直坚信时间是可以复制的。我牺牲了自己的大概十个小时写了这片文章，换来的是成千上万的求职者节约几天甚至几周时间浪费在无用的资源上。
上面的这些（算法与数据结构）+（Java多线程学习手册）+（计算机网络顶级教程）等学习资源
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
}
public static void main(String[] args){
System.out.println(“main begin”);
new helloworld();
}
}
8.5 static总结
public static void main(String[] args)
8.5.1 对java语句的解读
1）public代表公开的，在任何位置都可以访问；
2）static表示静态的，使用"类名."的方式访问，不需要创建对象
3）void表示main方法执行结束之后不返回任何值；
4）(String[] args)是参数列表；
8.5.2 什么时候定义为静态的？
1）方法描述的是动作，当所有的对象执行这个动作的时候，最终产生影响是一样的，那么这个动作已经不再属于某一个对象动作了，可以将这个动作提升为类级别的动作，模板级别的对象；
2）静态方法中无法直接访问实例变量和实例方法；
3）大多数方法都定义为实例方法，一般一个行为或一个动作在发生的时候都需要对象的参与而大多数“工具类”当中的方法都是静态的，因为工具类就是方便编程的，为了方便方法的调用，自然不需要new对象是最好的；
9、继承
====
1）继承是面向对象的三大特征之一，三大特征分别是：封装、继承、多态；
2）继承"基本"的作用是，代码复用。最重要的作用是：有了继承之后才有的"方法的覆盖"和"多态机制"；
3）继承语法格式：
[修饰符列表] class 类名 extends 父类名字{
类名 = 属性 + 方法;
}
4）java语言当中的继承只有单继承，一个类不能同时继承很多类，只能继承一个类。在C++中支持多继承；
5）关于继承中的一些术语：
B类继承A类，其中：
A类称为：父类、基类、超类、superclass；
B类称为：子类、派生类、subclass；
6）java语言中能继承父类的哪些数据？
-
私有的不支持继承；
-
构造方法不支持继承；
-
其他数据都有被继承；
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-p2nyF9zQ-1713426123868)]
[外链图片转存中…(img-gG2sATmn-1713426123869)]
[外链图片转存中…(img-MSdWByB7-1713426123869)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）
写在最后
可能有人会问我为什么愿意去花时间帮助大家实现求职梦想，因为我一直坚信时间是可以复制的。我牺牲了自己的大概十个小时写了这片文章，换来的是成千上万的求职者节约几天甚至几周时间浪费在无用的资源上。
[外链图片转存中…(img-I9vZNdT4-1713426123869)]
[外链图片转存中…(img-muFjUND3-1713426123869)]
上面的这些（算法与数据结构）+（Java多线程学习手册）+（计算机网络顶级教程）等学习资源
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
258
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
