Java SE: 面向对象编程（基础部分）

最新推荐文章于 2024-11-01 14:48:20 发布

白能白

最新推荐文章于 2024-11-01 14:48:20 发布

阅读量250

点赞数

分类专栏： JavaSE笔记文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_48409574/article/details/122100559

版权

JavaSE笔记专栏收录该内容

16 篇文章 0 订阅

订阅专栏

食用前说明：

本文章内容来自B站韩顺平老师的课堂笔记，本人只是将其进行自我整理，内容有所删减，韩顺平老师的B站课程AV号：BV1fh411y7R8

本文章内容来自韩顺平老师的课堂笔记的第7章面向对象编程（基础部分），本章内容重点掌握：成员方法、成员传参机制、构造器，为后面的封装、继承和多态打基础！

按照惯例给出直达本章的链接：

类与对象

7.1 类与对象

7.1.1 属性/成员变量/字段

基本介绍

属性/成员变量/字段属于同一个东西

7.1.2 属性使用注意事项和细节

属性的定义类型可以为任意类型（包含基本类型和引用类型）

属性有默认值，规则和数组一致。

数据类型默认值
int , short , byte , long 0
float ,double 0.0
char \u0000
boolean false
String null

数据类型	默认值
int , short , byte , long	0
float ,double	0.0
char	\u0000
boolean	false
String	null

7.1.3 如何创建对象

注释：

 //创建 Person 对象
 //p1 是对象名(对象引用)
 //new Person() 创建的对象空间(数据) 才是真正的对象
 Person p1 = new Person();

先声明再创建
```
 Cat cat;
 cat = new Cat();
```
直接创建
```
 Cat cat = new Cat();
```

7.1.4 如何访问属性

基本语法
- 对象名.属性名;
```
 cat.name;
 cat.age;
 cat.color;
```

7.1.5 类和对象的内存分配机制

Java 内存的结构分析

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

2、堆：存放对象(Cat cat , 数组等) (存放使用new创建的对象，全局变量)

3、方法区：常量池(常量，比如字符串)，类加载信息[只会加载一次]

4、示意图

7.2 成员方法

7.2.1 基本介绍

为解决有关一类问题的问题，我们将解决这一类问题的代码进行单独提取成一个方法
方法的使用可以让代码更简洁，便于维护代码，增加代码的重用性

7.2.2 成员方法的定义

语法规范：

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

案例演示

 //单个返回值
 public static int age(int birthday){...}
 //多个返回值
 static float interest(float principal, int year){...}
 
 public static int max(int num1, int num2) {
    int result;
    if (num1 > num2)
       result = num1;
    else
       result = num2;
  
    return result; 
 }

7.2.3 方法的调用

返回数据类型

一个方法最多有一个返回值 [ 返回多个结果时用：数组 ]

返回类型可以为：基本类型或引用类型(数组，对象)

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

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

案例演示

 /** 主方法 */
 public static void main(String[] args) {
     int i = 5;
     int j = 2;
     int k = max(i, j);//调用方法
     System.out.println( i + " 和 " + j + " 比较，最大值是：" + k);
 }
 
 /** 定义一个方法：返回两个整数变量较大的值 */
 public static int max(int num1, int num2) {
     int result;
     if (num1 > num2)
         result = num1;
     else
         result = num2;
 
     return result; 
 }

7.2.4 注意事项和使用细节

访问修饰符 (作用是控制，方法使用的范围)

[ 有四种: public, protected, 默认, private ]

不写的话就是：默认访问
返回数据类型
1. 一个方法最多有一个返回值 [ 返回多个结果时用：数组 ]
2. 返回类型可以为：基本类型或引用类型(数组，对象)
3. 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值; 而且要求返回值类型必须和 return 的值类型一致或兼容
4. 如果方法是 void，则方法体中可以没有 return 语句，或者只写 return ;

方法：

1、一个方法可以，一个参数、多个参数甚至没有参数，多个参数时中间用逗号隔开，比如 getSum(int n1,int n2) 2、参数类型可以为：基本类型、引用类型，甚至任意类型，比如 printArr(int map) 3、调用带参数的方法时，传入的实参要不相同类型，或者是兼容类型的参数！ 4、调用带参数的方法时，传入的实参的类型要一致，实参的个数，实参的顺序也必须一致

方法的调用细节说明
1. 若在同一个类中，可直接调调用，
  - 格式：方法名加参数(可选)
2. 若是跨类进行调用
  - 格式：类名.方法名

7.3 类定义的完善演变

一开始的定义

学完构造器后类的定义

学完包后类的定义

学完继承后类的定义

7.4 成员方法传参机制

基本数据类型传参，本质是数值的拷贝

形参的改变，不影响实参
引用数据类型传参，本质是拷贝地址

形参的改变，影响实参

7.5 方法递归调用

简单理解就是：递归就是方法自己调用自己

7.5.1 递归重要规则

1、执行一个方法时，就创建一个新的受保护的独立空间(栈空间)

2、方法的局部变量是独立的，不会相互影响, 比如n变量

3、如果方法中使用的是引用类型变量(比如数组，对象)，就会共享该引用类型的数据.

4、递归必须向退出递归的条件逼近，否则就是无限递归,出现 StackOverflowError，死龟了：）

5、当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就返回给谁，同时当方法执行完毕或者返回时，该方法也就执完毕。

案例演示

 public class MultiTable {
     public static void main(String args[]) { 
         m(9); 
     } 
     /** 
    * 打印出九九乘法表 
    * @param i 
    */
     public static void m(int i) { 
         if (i == 1) { 
             System.out.println("1*1=1 "); 
         } else { 
             m(i - 1); 
             for (int j = 1; j <= i; j++) { 
                 System.out.print(j + "*" + i + "=" + j * i + " "); 
             } 
             System.out.println(); 
         } 
     }  
 }

运行结果

 1*1=1
 1*2=2 2*2=4
 1*3=3 2*3=6 3*3=9
 1*4=4 2*4=8 3*4=12 4*4=16
 1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
 1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
 1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
 1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
 1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

7.6 方法重载(OverLoad)

7.6.1 基本介绍

java 中允许同一个类中，多个同名方法的存在，但形参列表不一致！

7.6.2 重载的好处

减轻了起名的麻烦
也减轻了记名的麻烦

7.6.3 案例说明

下边的类中调用了多个 println() 方法，并无报错

 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);
 }

运行结果

 100
 hello,world
 h
 1.1
 true

7.7 可变参数

7.7.1基本概念

案例演示

 public int sum(int... nums) {}

1、可变参数的实参可以为0个或任意多个。

2、可变参数的实参可以为数组。

3、可变参数的本质就是数组。

4、可变参数和普通类型参数可以混用，但要保证只有一个可变参数，并且可变参数排在最后

5、一个形参列表中只能出现一个可变参数

7.8 作用域

7.8.1 作用域分为

全局变量，即为属性

局部变量，
案例演示说明

全局变量：也就是属性，作用域为整个类体 Cat类，包括在Cat类下创建的方法里都可以调用
```
 class Cat {
     int n = 10;//全局变量
     //方法里任可以调用n
     public void eat() {
         int num = 1;//局部变量
         System.out.println("n=" + n);
     }
 }
```
局部变量创建时，必须要初始化 (给一个数值)

全局变量则可以不给值，应为全局变量有默认值

7.8.2 注意事项和细节使用

属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。

局部变量，生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁

作用域范围不同

全局变量/属性：可以被本类使用，或其他类使用（通过对象被调用）

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

修饰符不同全局变量/属性 可以加修饰符 局部变量 不可以加修饰符

7.9 构造方法/构造器

构造器起到的作用，类似提醒器，提醒程序员初始化变量

7.9.1 基本介绍

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

方法名和类名相同
没有返回值
在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。

7.10 对象创建的流程分析

案例演示

 class Person{//类Person
     int age=90;
     String name;
     Person(String n,int a){//构造器
         name=n;//给属性赋值
         age=a;//.
     }
 }
 Person p=new Person("小倩",20);

流程分析
1. 加载Person类信息(Person.class)，只会加载载一次
2. 在堆中分配空间(地址)
3. 完成对象初始化
  1. 默认初始化 age=0 name=null
  2. 显式初始化 age=90,name=null,
  3. 构造器的初始化 age =20, name=小倩
4. 在对象在堆中的地址,返回给合 p(p 是对象名,也可以理解成是对象)

7.11 this 关键字

this本质等同于：自指当前对象。简单说就是：哪个对象调用，this就代表哪个对象（this为隐藏属性）

7.11.1 this 的注意事项和使用细节

1、this 关键字可以用来访问本类的属性、方法、构造器

2、this 用于区分当前类的属性和局部变量

3、访问成员方法的语法：this.方法名(参数列表);

4、访问构造器语法：this(参数列表); 注意只能在构造器中使用(即只能在构造器中访问另外一个构造器, 必须放在第一条语句)

5、this 不能在类定义的外部使用，只能在类定义的方法中使用。