2024年网安最新Java面向对象（适合零基础小白入门教程9）_java面向对象教程(1)

要求：
1、CLassName要求符合驼峰命名法，首字母大写，见名知意。
2、属性描述：外部特征，用于描述这个类别的一些特征，而这些特征通过一个"词"来描述清楚，比如姓名，年龄。使用变量来表示。——【成员变量】Field，词义"字段"
3、行为描述：能够干啥，用于描述这个类别的一些行为功能，而这些行为功能，是一个动作行为，比如吃饭，睡觉。使用方法来表示。——【成员方法】Method，词义"方法"
不要加static。

方法：就是一段具有独立功能的代码。


#### **2.2.1 step1声明类**

public class Person{//类的名字
​
}

#### **2.2.2 step2声明类中的【成员变量】**

public class Person {
//step2：成员变量
String name;//使用String类型的变量name，表示人类中的姓名

int age;//使用int类型的变量age，表示人类中的年龄

char sex;//使用char类型的变量sex，表示人类中的性别

}

#### **2.2.3 step3声明类中的【成员方法】**

public class Person {
//step2：成员变量
String name;//使用String类型的变量name，表示人类中的姓名

int age;//使用int类型的变量age，表示人类中的年龄

char sex;//使用char类型的变量sex，表示人类中的性别

//step3：成员方法
public void eat(){
System.out.println(“吃饭啦。。”);
}

public void sleep(){
System.out.println(“睡觉啦。。”);
}

public void daDouDou(){
System.out.println(“打豆豆。。。”);
}
}
​

#### **2.3、类的对象**


#### **2.3.1 创建类的对象**


创建对象，也叫做类的实例化。对象，也叫类的实例。

/*
new关键字
new，词义：新的，新建
new 关键字，专门用于新建对象。
/
Scanner sc = new Scanner();//Scanner也是个类，Person也是个类。
int[] arr = new int[5];
​
语法结构：
/
类名 对象名 = new 类名();
*/
Person p1 = new Person();

step2：根据类，实例化对象


step1：创建类


#### **2.3.2通过对象访问属性**

/*
int[] arr = new int[5];
获取数组的长度：
arr.length
arr的长度
*/
对象访问属性的语法：就是一个.
//给对象的属性，进行赋值
p1.name = “王二狗”;//给p1这个对象的name属性进行赋值
p1.age = 18;
p1.sex = ‘男’;
​
​
//获取对象的属性值
System.out.println(“姓名：”+p1.name);
System.out.println(“年龄：”+p1.age);
System.out.println(“性别：”+p1.sex);

#### **2.3.3通过对象访问方法**

/*
Scanner sc = new Scanner();
sc.nextInt();
*/
Scanner，就是一个class，一个类
sc，是根据Scanner创建出来的一个对象
​
对象调用类中的方法，语法，也是.
对象.方法名();
p1.eat();
p1.sleep();
p1.daDouDou();

#### **2.3 内存分析**


实例代码：

package com.qf.demo01;
​
public class Test1Person {
​
public static void main(String[] args) {
//step1：创建Person类的对象
//语法：类名 对象名 = new 类名();

Person p1 = new Person();
System.out.println(p1);//打印p1的值，p1是引用类型，打印都是p1指向的对象的地址。

System.out.println(p1.name);
System.out.println(p1.age);
System.out.println(p1.sex);




/*
 * com.qf.demo01.Person@15db9742
 * 包名.类名@编码值  ---->理解为p1的内存地址。
 * 
 * java中的数据类型：
 *  基本类型：byte，short，char，int，long，bolean，float，double
 *  引用类型：
 *      数组，类类类型
 * 
 */
//step2：通过对象访问属性，语法是.
//给对象的属性，进行赋值
p1.name = "王二狗";//给p1这个对象的name属性进行赋值
p1.age = 18;
p1.sex = '男';


//获取对象的属性值
System.out.println("姓名："+p1.name);
System.out.println("年龄："+p1.age);
System.out.println("性别："+p1.sex);


//step3：通过对象，访问成员方法--->理解为就是对象调用成员方法
p1.eat();
p1.sleep();
p1.daDouDou();

}
​
}
​

内存分析图


![](https://img-blog.csdnimg.cn/2e74598d08c249dc882c2f6b889480e4.png)


 示例代码：

package com.qf.demo01;
​
public class Test2Person {
​
public static void main(String[] args) {
//1.创建一个Person类的对象
Person p1 = new Person();
System.out.println(p1);//p1的内存地址：com.qf.demo01.Person@15db9742

p1.name = "张三狗";
p1.age = 19;
p1.sex = '男';

System.out.println(p1.name);//张三狗
System.out.println(p1.age);//19
System.out.println(p1.sex);//男
      
//2.再创建一个Person类的对象

Person p2 = new Person();
System.out.println(p2);//p2的内存地址，com.qf.demo01.Person@6d06d69c

p2.name = "李小花";
p2.age = 17;
p2.sex = '女';

System.out.println(p2.name);//李小花
System.out.println(p2.age);//17
System.out.println(p2.sex);//女
  
//3.
Person p3 = null;//仅仅声明了Person类型的对象p3，但是实际上，并没有在堆内存中，创建出真正的对象。

/*
 * NullPointerException，空指针异常
 * 
 * 对象不存在，就是个null，
 *  强行的访问对象的属性或调用方法，就会空指针异常。
 */
//System.out.println("---->"+p3.name);//报错啦：NullPointerException

p3 = p1;//将p1的值（p1对象的内存地址），赋值给p3，结果-->p1和p3存储的是同一个对象的内存地址。

p3.name = "李铁柱";
System.out.println(p1.name);//李铁柱
System.out.println(p2.name);//李小花
System.out.println(p3.name);//李铁柱

Person p4 = new Person();
System.out.println(p4);//?

p4.name = "王二丫";
p4.age = 18;
p4.sex = '女';
System.out.println(p4.name );
System.out.println(p4.age);
System.out.println(p4.sex);

p4 = p1;//改变对象的内存地址了，就不再指向原来的内存对象。
System.out.println(p1.name);
System.out.println(p3.name);
System.out.println(p4.name);

}
​
}
​

内存分析图：


![](https://img-blog.csdnimg.cn/ae28a6b9155b4aa6a18c8a4dae0498bd.png)


 


#### **2.5、方法的重载：overload**

概念：一个类中的，一个功能方法的多种体现形式（有不同的方法体）。
举例：
1、人类，有吃的功能：eat()
eat(食物);
eat(药);
eat(口香糖);

2、求和的功能：
        getSum(int i,int j);
        getSum(double d1, double d2);
3、水：
    常温：液态
    0度以下：固态
    100度以上：气态

就是同一个功能的方法，因为参数的不同，调用的具体的方法也不同。
如何判定多个方法是否是重载的？衡量标准，要同时满足以下三条：
A：必须同一个类中。
B：方法名称必须一致。
C：参数列表必须不同。（顺序，个数，类型）

    和static，public，返回值，void等等都没有关系。

优点：
1、简化了开发的压力
2、简化了记忆的压力
3、调用方法更方便，更简洁，又满足了不同的情况

基本原理：
当方法名称一致时，通过形式参数列表的不同来选择要执行的方法。

示例代码：

package com.qf.demo01.overload;
​
import java.util.Arrays;
​
/*

• 方法的重载：
• 同一个功能：
• 根据参数的不同，执行的具体的方法也不同
• 衡量方法是否重载：
• 1、同一个类中
• 2、方法名必须一致
• 3、参数列表必须不同：类型，个数，顺序
  */
  public class Test1 {
  //求两个数的和：

//求两个整数的和
public static void getSum(int i,int j){
int sum = i + j;
System.out.println(i+" + " + j +“的总和是：”+sum);
}

public static void getSum(double d1, double d2){
double sum = d1 + d2;
System.out.println(“总和是：”+sum);
}

public static void getSum(int i,double j){

}

public static void getSum(double d1,int i1){

}
​
public static void main(String[] args) {
getSum(1, 2);

getSum(3.14, 4.21);

​

}

}
​

#### **2.6、构造方法**


构造方法：是一个很特殊的方法。


* 声明的语法：public 类名(){}
	+ 修饰符：只能有访问权限的修饰符，public。不能加static。
	+ 返回值：没有返回值，也不能写void。
	+ 方法名：必须和类名相同
* 调用的方式：new 关键字调用
	+ new关键字后面跟着构造方法即可。
* 作用：专门用于创建对象。


普通方法：一段具有特殊功能的代码。而且可以被多次调用执行。


* 声明的语法：public static void main(String[] args){}
* 调用的方式：方法名(实参)；
* 作用：1、避免重复的代码增强程序的可读性。2、提高程序的可维护性。

1、编写java的源代码(给人看)：XXX.java
2、将源文件进行编译(机器执行的就是这个字节码文件)：XXX.class
javac命令 javac XXX.java
3、JVM执行字节码文件：XXX.class
java命令 java XXX
​
Java反编译工具：我们现在将class文件，进行反编译，可以看见类似于底层语言
javap -c -l -private XXX.class

#### **2.6.1 Java编译器提供的默认的构造方法**

问题：创建对象的时候，代码：new Person();调用的这个Person()这个方法，在程序中并没有写，哪来的？
​
试着将Person.class文件进行反编译：

![](https://img-blog.csdnimg.cn/c37be4092caa4deb9497160b22d16d0b.png)


 结论：通过反编译工具，发现了一些和源代码不相符的内容，这就是javac编译器，自动给代码中添加的构造方法。用于创建对象。


java编译器，发现代码中没有任何的构造方法，在编译时，会自动的帮我们添加一个无参的构造方法。


如果代码中自己写了构造方法，那么编译器不再帮我们添加无参的构造方法。


#### **2.6.2 自定义的构造方法**

记住一条：如果一个类中，没有写任何的构造方法，那么编译器自动添加一个无参的构造方法。但是如果你写了构造方法，那么编译器不再添加了。
我们写程序的规则：
无参构造要写
有参构造看实际情况
一个类中可以有多个构造方法的。也是方法的重载。

创建对象的语法：
new 构造方法(可能有参数);

如果添加自己定义的构造方法：
语法规则：
public 类名(){
​
}
public 类名(参数列表){
将参数的数值，赋值给属性即可。
}

如何创建一个对象？就是通过new这个关键字，调用一个类的构造方法。就创建了对象。


先声明，再调用--->普通方法，还适合构造方法。


如果一个类中，没有手动的写一个构造方法的话，那么编译器会自动的添加一个无参的构造方法。


示例代码：

class Person{
String name;
int age;
public Person(){//无参的构造方法

}
public Person(String n,int a){//有参的构造方法
    name = n;
    age = a;
}

}
class Test{
public static void main(String[] args){
Person p1 = new Person();
p1.name = “李小花”;
p1.age = 18;

    Person p2 = new Person("王二狗",18);
}

}

注意点：



> 
>  1、如果代码中，没有写构造方法。编译器会自动的添加一个无参的构造方法。 
>    
>  2、如果代码中，写了构造方法。编译器都不会再给我们添加无参的构造方法。编码习惯：写了有参构造，再写上无参构造。 
> 


对比一下构造方法和普通方法：


![](https://img-blog.csdnimg.cn/37edc09833c04169991acb9ecf61f6b6.png)


####  **2.7、this关键字**


词义：这个。


#### **2.7.1 就近原则问题**

当写代码的时候，要给成员变量，参数，局部变量等等，要进行命名。根据见名知意的原则，很容易就命名冲突了。
在程序当中，有个就近原则，一旦名字冲突，就要看离哪个声明近。
导致名称中成员变量和局部变量的命名冲突！！！
public Person(String name,int age){//name=“李小花”
name = name; //=两侧的name，都是指参数
age = age;
}
因为命名规范，见名知意，成员变量和局部变量，命名相同了。
因为就近原则问题：构造方法Person中，name和age，都会看成了这个参数，就是局部变量。

希望有一种方式，来告诉编译器：=左边的是成员变量，=右边的才是参数。
可以借助于this这个关键字解决。

#### **2.7.2 this的用法一**


表示当前对象。

this.属性，没有this的就是局部变量。可以解决命名冲突的问题。
public Person(String name,int age){//name=“李小花”
this.name = name; //=左侧的是this的name属性
this.age = age;
}
使用this关键字，明确的告诉编译器，this后的这个name，就是成员变量。对象的属性。没有this的就是参数。
解决成员变量和局部变量的命名冲突。
this点的就是成员变量，没有this的就是局部变量。

示例代码：

package com.qf.demo03;
​
public class Person {
//成员变量
String name;//属性，成员变量，人有姓名
int age;

public Person(){

}

/*

• 就近原则：成员变量和局部变量命名冲突了。方法中name默认都是参数。
  */
  public Person(String name,int age){//name=“李小花”
  this.name = name;
  this.age = age;
  }

public void eat(){
System.out.println(name+“,吃东西啦。。”);
}

//this，当前的对象。谁调用谁就是当前的对象
//当p1调用的时候，this就指代p1
//当p2调用的时候，shis就指代p2

//在类中提供一个功能：成员方法
public void showInfo(){
System.out.println(“姓名：”+this.name+“,年龄：”+age);
}
}
​

学习路线：

这个方向初期比较容易入门一些，掌握一些基本技术，拿起各种现成的工具就可以开黑了。不过，要想从脚本小子变成黑客大神，这个方向越往后，需要学习和掌握的东西就会越来越多以下是网络渗透需要学习的内容：

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以点击这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！