①面向对象（oop）基础

鑫青年697

已于 2022-06-06 17:29:22 修改

阅读量108

点赞数

文章标签： java 开发语言

于 2022-05-31 15:25:25 首次发布

本文链接：https://blog.csdn.net/weixin_66456927/article/details/125004565

版权

本文详细介绍了Java中的类与对象的概念及其区别，包括对象的内存分配、属性和方法的定义与访问，以及构造器、this关键字的使用。内容涵盖了对象的创建、方法调用机制、作用域规则、成员变量与局部变量的差异，同时讲解了方法的重载、可变参数和构造器的运用。通过对实例的解析，深入理解Java面向对象编程的基础知识。

摘要由CSDN通过智能技术生成

学习资料：哔站《韩顺平循序渐进学Java》

类与对象关系示意图

类与对象的区别与联系

（1），类是抽象的，概念的。代表一类事物，即是一种数据类型

（2），对象是具体的，实际的，代表一个具体事物，即是实例

（3），类是对象的模板，对象是类的一个个体，对应一个实例

对象在内存中的存在形式（重要！）

1.1，属性/成员变量/字段

（1），基本介绍：

1) 从概念或叫法上看：成员变量 = 属性 = field(字段) （即成员变量是用来表示属性的)。

2) 属性是类的一个组成部分，一般是基本数据类型,也可是引用类型(对象，数组)。

1.1,1，注意事项和细节

1) 属性的定义语法同变量，示例：访问修饰符属性类型属性名

2) 属性的定义类型可以为任意类型，包含基本类型或引用类型

3) 属性如果不赋值，有默认值，规则和数组一致。具体说: int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000， boolean false，String null

public class PropertiesDetail {
//编写一个 main 方法
public static void main(String[] args) {
//创建 Person 对象
//p1 是对象名(对象引用)
//new Person() 创建的对象空间(数据) 才是真正的对象
Person p1 = new Person();
//对象的属性默认值，遵守数组规则:
//int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null
System.out.println("\n 当前这个人的信息");
System.out.println("age=" + p1.age + " name=" + p1.name + " sal=" + p1.sal + " isPass=" + p1.isPass) ;
}
}
class Person {
//四个属性
int age;
String name;
double sal;
boolean isPass;
}

1.1.2，如何创建对象

1) 先声明再创建 Cat cat ; //声明对象cat

cat = new Cat(); //创建

2) 直接创建 Cat cat = new C;

1.1.7，如何访问属性

（1）基本语法：对象名.属性名;

1.1.3，类和对象的内存分配机制（重要！）

（1），Java内存结构分析

1) 栈：一般存放基本数据类型(局部变量)

2) 堆：存放对象(Cat cat , 数组等)

3) 方法区：常量池(常量，比如字符串)，类加载信息

（2），Java创建对象的流程简单分析

/**
1) 先加载 Person 类信息(属性和方法信息, 只会加载一次)
2) 在堆中分配空间, 进行默认初始化(看规则)
3) 把地址赋给 p , p 就指向对象
4) 进行指定初始化， 比如 p.name =”jack”; p.age = 20;
*/


Person p = new Person();
p.name = “jack”;
p.age = 10

1.2，成员方法

1.2.1，基本介绍：

在某些情况下，我们要需要定义成员方法(简称方法)。比如人类:除了有一些属性外( 年龄，姓名..),我们人类还有一些行为比如:可以说话、跑步..,通过学习，还可以做算术题。这时就要用成员方法才能完成。

public class Method01 {
//编写一个 main 方法
public static void main(String[] args) {
//方法使用
//1. 方法写好后，如果不去调用(使用)，不会输出
//2. 先创建对象 ,然后调用方法即可
Person p1 = new Person();
p1.speak(); //调用方法
p1.cal01(); //调用 cal01 方法
p1.cal02(5); //调用 cal02 方法，同时给 n = 5
p1.cal02(10); //调用 cal02 方法，同时给 n = 10
//调用 getSum 方法，同时 num1=10, num2=20

//把 方法 getSum 返回的值，赋给 变量 returnRes
int returnRes = p1.getSum(10, 20);
System.out.println("getSum 方法返回的值=" + returnRes);
}
}
class Person {
String name;
int age;
//方法(成员方法)
//添加 speak 成员方法,输出 “我是一个好人”
//老韩解读
//1. public 表示方法是公开
//2. void ： 表示方法没有返回值
//3. speak() : speak 是方法名， () 形参列表
//4. {} 方法体，可以写我们要执行的代码
//5. System.out.println("我是一个好人"); 表示我们的方法就是输出一句话
public void speak() {
System.out.println("我是一个好人");
}
//添加 cal01 成员方法,可以计算从 1+..+1000 的结果
public void cal01() {
//循环完成

int res = 0;
for(int i = 1; i <= 1000; i++) {
res += i;
}
System.out.println("cal01 方法 计算结果=" + res);
}
//添加 cal02 成员方法,该方法可以接收一个数 n，计算从 1+..+n 的结果
//老韩解读
//1. (int n) 形参列表， 表示当前有一个形参 n, 可以接收用户输入
public void cal02(int n) {
//循环完成
int res = 0;
for(int i = 1; i <= n; i++) {
res += i;
}
System.out.println("cal02 方法 计算结果=" + res);
}
//添加 getSum 成员方法,可以计算两个数的和
//老韩解读
//1. public 表示方法是公开的
//2. int :表示方法执行后，返回一个 int 值
//3. getSum 方法名
//4. (int num1, int num2) 形参列表，2 个形参，可以接收用户传入的两个数
//5. return res; 表示把 res 的值， 返回
public int getSum(int num1, int num2) {

int res = num1 + num2;
return res;
}
}

1.2.2，方法调用机制原理（重要！）

1.2.3，为什么需要成员方法

1) 提高代码的复用性

2) 可以将实现的细节封装起来，然后供其他用户来调用即可

1.2.4，成员方法的定义

访问修饰符返回数据类型方法名（形参列表..） {//方法体语句； return 返回值; }

1) 形参列表：表示成员方法输入 cal(int n) ， getSum(int num1,int num2)

2) 返回数据类型：表示成员方法输出, void 表示没有返回值

3) 方法主体：表示为了实现某一功能代码块

4) return 语句不是必须的。

1.2.5，注意事项和细节

①访问修饰符 (作用是控制方法使用的范围) 如果不写默认访问，[有四种: public, protected, 默认, private]

②返回数据类型

1) 一个方法最多有一个返回值 [思考，如何返回多个结果返回数组 ]

2) 返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)

3) 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值; 而且要求返回值类型必须和 return 的值类型一致或兼容

4) 如果方法是 void，则方法体中可以没有 return 语句，或者只写 return

③方法名遵循驼峰命名法，最好见名知义，表达出该功能的意思即可, 比如得到两个数的和 getSum, 开发中按照规范

④形参列表，方法体

1.2.6，方法调用细节说明！！！

1.2.7，类定义的完善

1.2.8，数据类型的传参机制

1），基本数据类型传递的是值（值拷贝），形参的任何改变影响不了实参

2），引用数据类型传递的是地址（传递的也是值，但是值是地址），可以通过形参影响实参。

1.2.9,方法的重载

1，基本介绍：Java中允许同一个类多个同名方法的存在，但要求，形参列表不一致

2，好处：减轻了起名的麻烦，减轻了记名的麻烦

public class OverLoad01 {
//编写一个 main 方法
public static void main(String[] args) {
// System.out.println(100);
// System.out.println("hello,world");
// System.out.println('h');
// System.out.println(1.1);
// System.out.println(true);
//
MyCalculator mc = new MyCalculator();
System.out.println(mc.calculate(1, 2));
System.out.println(mc.calculate(1.1, 2));
System.out.println(mc.calculate(1, 2.1));
}
}
class MyCalculator {
//下面的四个 calculate 方法构成了重载
//两个整数的和
public int calculate(int n1, int n2) {
System.out.println("calculate(int n1, int n2) 被调用");
 
return n1 + n2;
}
//没有构成方法重载, 仍然是错误的，因为是方法的重复定义
// public void calculate(int n1, int n2) {
// System.out.println("calculate(int n1, int n2) 被调用");
// int res = n1 + n2;
// }
//看看下面是否构成重载, 没有构成，而是方法的重复定义,就错了
// public int calculate(int a1, int a2) {
// System.out.println("calculate(int n1, int n2) 被调用");
// return a1 + a2;
// }
//一个整数，一个 double 的和
public double calculate(int n1, double n2) {
return n1 + n2;
}
//一个 double ,一个 Int 和
public double calculate(double n1, int n2) {
System.out.println("calculate(double n1, int n2) 被调用..");
return n1 + n2;
}
//三个 int 的和
public int calculate(int n1, int n2,int n3) {
 
return n1 + n2 + n2;
}
}

3，注意事项和使用细节：

1），方法名：必须相同

2），形参列表：必须不同（形参类型或个数或顺序必须有一个不同，参数名无要求）

3），返回类型：无要求

1.2.10,可变参数

1，基本介绍：Java中允许同一类中多个同名同功能但参数个数不同的方法存在，封装成一个方法，就可以通过可变参数实现。

2，基本语法：访问修饰符返回类型方法名(数据类型... 形参名) { }

//1. int... 表示接受的是可变参数，类型是 int ,即可以接收多个 int(0-多)
//2. 使用可变参数时，可以当做数组来使用 即 nums 可以当做数组
//3. 遍历 nums 求和即可
public int sum(int... nums) {
//System.out.println("接收的参数个数=" + nums.length);
int res = 0;
for(int i = 0; i < nums.length; i++) {
res += nums[i];
}
return res;
}

3，注意事项和使用细节：

1），可变参数的实参可以为0个或任意多个

2），可变参数的实参可以为数组

3），可变参数的本质就是数组

4），可变参数可以和普通类型的参数放在形参列表里，但必须保证可变参数在最后

5），一个形参列表里只能出现一个可变参数

public class VarParameterDetail {
//编写一个 main 方法
public static void main(String[] args) {
 
//细节: 可变参数的实参可以为数组
int[] arr = {1, 2, 3};
T t1 = new T();
t1.f1(arr);
}
}
class T {
public void f1(int... nums) {
System.out.println("长度=" + nums.length);
}
//细节: 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
public void f2(String str, double... nums) {
}
//细节: 一个形参列表中只能出现一个可变参数
//下面的写法是错的. // public void f3(int... nums1, double... nums2) {
// }
}

1.2.11，作用域

1，基本使用：

1），在Java编程中，主要的变量就是属性（成员变量）和局部变量

2），我们所说的局部变量通常是指定义在成员方法中的变量

3），Java中作用域的分类：

（1），全局变量：也就是成员变量，作用域为整个类体。

（2），局部变量：也就是除了属性之外的变量，作用域为定义它的代码块中

4）,全局变量可以不赋值，直接使用，因为有默认值。局部变量必须赋值后才能使用，因为没有默认值。

public class VarScope {
//编写一个 main 方法
public static void main(String[] args) {
}
}
 
class Cat {
//全局变量：也就是属性，作用域为整个类体 Cat 类：cry eat 等方法使用属性
//属性在定义时，可以直接赋值
int age = 10; //指定的值是 10
//全局变量(属性)可以不赋值，直接使用，因为有默认值，
double weight; //默认值是 0.0
public void hi() {
//局部变量必须赋值后，才能使用，因为没有默认值
int num = 1;
String address = "北京的猫";
System.out.println("num=" + num);
System.out.println("address=" + address);
System.out.println("weight=" + weight);//属性
}
public void cry() {
//1. 局部变量一般是指在成员方法中定义的变量
//2. n 和 name 就是局部变量
//3. n 和 name 的作用域在 cry 方法中
int n = 10;
String name = "jack";
System.out.println("在 cry 中使用属性 age=" + age);
}
 
public void eat() {
System.out.println("在 eat 中使用属性 age=" + age);
//System.out.println("在 eat 中使用 cry 的变量 name=" + name);//错误
}
}

2，注意事项和使用细节：

1），属性和局部变量可以重名，访问时遵循就近原则

2），在同一个作用域中，比如同一个方法中，两个局部变量，不能重名。

3），属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。局部变量的生命周期较短，伴随着代码块的执行而创建，伴随着代码块的结束而销毁。即在一次方法的调用的过程中。

4），作用域范围不同：

（1），成员变量（属性）：可以被本类使用，或者其他类使用（通过对象名调用）

（2），局部变量：只能在本类对应的方法中使用

5），修饰符不同：

属性可以添加修饰符，局部变量不可以添加修饰符。

public class VarScopeDetail {
 
//编写一个 main 方法
public static void main(String[] args) {
Person p1 = new Person();
/*
属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。
局部变量，生命周期较短，伴随着它的代码块的执行而创建，
伴随着代码块的结束而销毁。即在一次方法调用过程中
*/
//p1.say();//当执行 say 方法时，say 方法的局部变量比如 name,会创建，当 say 执行完毕后
//name 局部变量就销毁,但是属性(全局变量)仍然可以使用
//
T t1 = new T();
t1.test(); //第 1 种跨类访问对象属性的方式
t1.test2(p1);//第 2 种跨类访问对象属性的方式
}
}
class T {
//全局变量/属性：可以被本类使用，或其他类使用（通过对象调用)
public void test() {
Person p1 = new Person();
System.out.println(p1.name);//jack
}
 
public void test2(Person p) {
System.out.println(p.name);//jack
}
}
class Person {
//细节: 属性可以加修饰符(public protected private..)
// 局部变量不能加修饰符
public int age = 20;
String name = "jack";
public void say() {
//细节 属性和局部变量可以重名，访问时遵循就近原则
String name = "king";
System.out.println("say() name=" + name);
}
public void hi() {
String address = "北京";
//String address = "上海";//错误,重复定义变量
String name = "hsp";//可以
}
}

1.2.12，构造器/构造方法

1，基本语法：

【访问修饰符】方法名（参数列表）{方法体}；

说明：

1），构造器的修饰符可以是默认，也可以是其他修饰符

2），构造器没有返回值

3），方法名和类名字必须一样

4），参数列表和成员方法一样的规则

5），构造器的调用由系统完成

2，基本介绍：

构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点：

1) 方法名和类名相同

2) 没有返回值

3) 在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。

public class Constructor01 {
 
//编写一个 main 方法
public static void main(String[] args) {
//当我们 new 一个对象时，直接通过构造器指定名字和年龄
Person p1 = new Person("smith", 80);
System.out.println("p1 的信息如下");
System.out.println("p1 对象 name=" + p1.name);//smith
System.out.println("p1 对象 age=" + p1.age);//80
}
}
//在创建人类的对象时，就直接指定这个对象的年龄和姓名
//
class Person {
String name;
int age;
//构造器
//老韩解读
//1. 构造器没有返回值, 也不能写 void
//2. 构造器的名称和类 Person 一样
//3. (String pName, int pAge) 是构造器形参列表，规则和成员方法一样
public Person(String pName, int pAge) {
System.out.println("构造器被调用~~ 完成对象的属性初始化");
name = pName;
age = pAge;
}
 
}

3，注意事项和使用细节：

1），一个类可以定义多个不同构造器，即构造器重载。

2），构造器名和类名必须相同。

3），构造器没有返回值。

4），构造器是完成对对象的初始化，不是创建对象。

5），在创建对象时，系统会自动调用该类的构造器。

6），如果程序员没有定义构造器，系统会自动生成默认的无惨构造器。除非显示的定义一下。比如：public Dog(){};

public class ConstructorDetail {
//编写一个 main 方法
public static void main(String[] args) {
Person p1 = new Person("king", 40);//第 1 个构造器
Person p2 = new Person("tom");//第 2 个构造器
Dog dog1 = new Dog();//使用的是默认的无参构造器
 
}
}
class Dog {
//如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)
//使用 javap 指令 反编译看看
/*
默认构造器
Dog() {
}
*/
//一旦定义了自己的构造器,默认的构造器就覆盖了，就不能再使用默认的无参构造器，
//除非显式的定义一下,即: Dog(){} 写 (这点很重要)
//
public Dog(String dName) {
//... }
Dog() { //显式的定义一下 无参构造器
}
}
class Person {
String name;
int age;//默认 0
//第 1 个构造器
 
public Person(String pName, int pAge) {
name = pName;
age = pAge;
}
//第 2 个构造器, 只指定人名，不需要指定年龄
public Person(String pName) {
name = pName;
}
}