Java基础笔记（面向对象基础）

恐高宇航员

已于 2023-04-12 00:47:11 修改

阅读量216

点赞数

分类专栏： Java SE 文章标签： java 开发语言后端

于 2022-05-30 08:24:07 首次发布

本文链接：https://blog.csdn.net/sdjgh/article/details/125039802

版权

Java SE 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

6 面向对象(基础)

文章目录

6 面向对象(基础)

6.1 类与对象

基本介绍：
- 类是抽象的，概念的，代表一类事物,比如人类, 猫类…即它是数据类型
- 对象是具体的，实际的，代表一个具体事物，即是实例
- 类是对象的模板，对象是类的一个个体，对应一个实例
对象存在形式⭐️

6.1.1属性/成员变量

基本介绍：
- 从概念或叫法上看：成员变量 = 属性 =field(字段)
- 属性是类的一个组成部分，一般是基本数据类型,也可是引用类型(对象，数组)，比如定义猫类的 int age 就是属性
注意事项和细节：
1. 属性的定义语法同变量，示例：访问修饰符属性类型属性名
2. 访问修饰符：控制属性和访问范围，有四种访问修饰符 public,proctected,defaul,private
3. 属性的定义类型可以为任意类型，包含基本类型或引用类型
4. 属性如果不赋值，有默认值，规则和数组一致:
  
  int0,short 0, byte 0, long 0, float 0.0,double 0.0
  char \u0000,boolean false, String null

6.1.2如何创建对象

先声明在创建
```
Cat cat;
cat = new Cat();
```
直接创建
```
Cat = new Cat();
```
对象创建流程分析⭐️⭐️
1. 加载Person类信息(就是Person.class 且只加载一次)
2. 在堆中分配空间(地址)
3. 完成对象初始化
  
  **(3.1默认初始化 age = 0 name =null **
  
  **3.2显示初始化 age = 90 name = null **
  
  3.3构造器初始化 age = 20 name = 小倩)
4. 在对象在堆中的地址返回给P(P是对象名，是对象的引用)

6.1.3对象分配机制

Person p1 = new Person();
p1.age = 10;
p1.name = "小明";
Person p2 = p1//把p1赋给了p2，或让p2指向p1
System.out.println(p2.age);

Java内存结构分析：
1. 栈：一般存放基本数据类型(局部变量)
2. 堆：存放对象(Cat cat，数组等)
3. 方法区：常量池(常量，比如字符串)，类加载信息
Java创建对象流程⭐️
1. 先加载Person类信息(属性和方法信息，只会加载一次)
2. 在堆中分配空间，进行默认初始化(看规则)
3. 把地址赋给 p，p就指向对象
4. 行指定初始化，比如 p.name =" jack" p.age = 10
```
Person p = new Person();
p.name = "jack";
p.age = 10;
```

6.2 成员方法⭐️

方法定义：
1. 访问修饰符返回数据类型方法名(形参列表) {//方法体
  
  语句;
  
  return 返回值;
  
  }
  1. 形参列表：表示成员方法输入 call(int n)
  2. 数据类型(返回类型)：表示成员方法输出，void 表示没有返回值
  3. 方法主体：表示为了实现某一功能代码块
  4. return 语句不是必须的

6.2.1 调用方法

public 表示方法是公开
void：表示方法没有返回值
speak() ：speak是方法名，()形参列表
{}方法体，可以写我们要执行的代码
System.out.println(”我是一个好人”)；表示我们的方法就是输出一句话

p1.speak()为调用

public class Method01 {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.speak();
        p1.cal01();
        p1.cal02(10);
        int returnRes = p1.getSum(1,2);
        System.out.println(returnRes);
    }
}

class Person{
    String name;
    int age;

    public void speak(){
        System.out.println("你是一个呆猪");
    }
    public void cal01(){
        int res = 0;
        for (int i = 1;i <= 1000;i++){
            res += i;
        }
        System.out.println(res);
    }
    public void cal02(int n){
        int res = 0;
        for (int i = 1;i <= n;i++){
            res += i;
        }
        System.out.println(res);
    }
    public int getSum(int num1,int num2){
        int res = num1 + num2;
        return res;
    }
}

6.2.2 调用的内存机制

调用的内存机制：

public 表示方法是公开的
int：表示方法执行后，返回一个 int 值
getsum 方法名
(int num1， int num2) 形参列表，2个形参，可以接收用户传入的两个数

return res；表示把res 的值，返回

public int getSum(int num1,int num2){
        int res = num1 + num2;
        return res;
}

6.2.3 注意事项和细节

访问修饰符：
1. 作用是控制方法使用的适用范围，若果不写则默认访问
返回类型：
1. 一个方法最多有一个返回值
2. 返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
3. 方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值;要求返回值类型必须和return的值类型一致或兼容
4. 如果方法是void，则方法体中可以没有return语句，或者只写 return
方法名：
1. 方法名遵循驼峰法则
参数列表：
1. 一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开，比如 getSum(int n1,int n2)
2. 参数类型可以为任意类型，包含基本类型或引用类型，比如 printArr(intlIl map)
3. 调用参数的方法时，一定对应着参数列表传入相同类型或莱容类型的参数
4. 方法定义时的参数称为形式参数，简称形参；方法调用时的参数称为实际参数，简称实参，实参和形参的类型要一致或兼容、个数、顺序必须一致
方法体：
1. 里面写完成功能的具体的语句，可以为输入、输出、变量、运算、分支、循环、方法调用
2. 里面不能再定义方法！即：方法不能嵌套定义
方法调用细节：
1. 同一个类中的方法调用：直接调用即可
2. 跨类中的方法A类调用B类方法：需要通过对象名调用
3. 跨类的方法调用和方法的访问修饰符相关

6.3 成员方传法参机制⭐️⭐️

6.3.1 基本数据类型的传参数机制

传递的是值(拷贝)，形参的认何改变不影响实参

6.3.2 引用数据类型的传参数机制

引用类型传递的是地址(传递也是值，但是值是地址)，可以通过形参影响实参

6.4 递归

基本介绍：

递归就是方法自己调用自己,每次调用时传入不同的变量

递归调用内存机制

public class Recursion01 {
     public static void main(String[] args) {
         T t1 = new T();
         t1.test(5);
         int res = t1.factorial(5);
         System.out.println("res = "+ res);
 
     }
 }
 
class  T{
    public void test(int n){
        if(n > 2){
            test(n - 1);
        }
        System.out.println(n);
    }
 
    public int factorial(int n){
        if(n == 1){
            return 1;
        }else {
            return factorial(n - 1)*n;
        }
    }
}

注意事项和细节：
1. 执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
2. 方法的局部变量是独立的，不会相互影响，比如n变量
3. 如果方法中使用的是引用类型变量(比如数组、对象)，就会共享该引用类型的数据
4. 递归必须向退出递归的条件逼近，否则就是无限递归
5. 当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕，栈空间回收

6.5 方法重载 (overload)

基本介绍：

java中允许同一个类中，多个同名方法的存在，但要求形参列表不一致
注意事项和细节
1. 方法名：必须相同
2. 形参列表：必须不同(参数类型、个数、顺序)
3. 返回类型：无要求

6.6 可变参数

基本概念：

java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法，通过可变参数实现

基本语法：

访问修饰符 返回类型 方法名(**数据类型...** 形参名){}

注意事项和细节：
1. 可变参数的实参可以为0个或任意多个
2. 可变参数的实参可以为数组
3. 可变参数的本质就是数组
4. 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
5. 一个形参列表中只能出现一个可变参数

6.7 变量作用域⭐️

全局变量和局部变量：
1. 主要的变量就是属性(成员变量)和局部变量
2. 局部变量一般是指在成员方法中定义的变量
3. 全局变量：也就是属性，作用域为整个类体
4. 局部变量：也就是除了属性之外的其他变量，作用域为定义它的代码块中
5. 全局变量(属性)可以不赋值，直接使用，因为有默认值，局部变量必须赋值后，才能使用，因为没有默认值
注意事项和细节：
1. 全局变量和局部变量可以重名，访问时遵循就近原则
2. 在同一个作用域中，两个局部变量，不能重名
3. 全局变量生命周期长，伴随着对象的创建而创建，伴随着对象的销毁而销毁
4. 局部变量生命周期短，伴随着它的代码块的执行而创建，伴随着代码块的结束而结束：即在一次方法调用过程中
5. 作用域范围不同
  全局变量/属性：可以被本类使用，或其他类使用(通过对象调用)
  局部变量：只能在本类中对应的方法中使用
6. 修饰符不同
  全局变量/属性可以加修饰符
  局部变量不可以加修饰符

两种调用方式

public class VarScopeDetail {
    public static void main(String[] args) {
        E e1 = new E();
        e1.test();

        Per p1 = new Per();
        e1.test2(p1);
    }
}

class E{
    public void test(){
        Per p1 = new Per();
        System.out.println(p1.name);
    }
    public void test2(Per p){//接收一个类
        System.out.println(p.name);
    }
}

class Per{
    String name = "jack";
}

6.8 构造器⭐️

基本介绍：

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

基本语法：

[修饰符] 方法名 (行参列表){
  方法体;
}

注意事项和细节：

修饰符可以默认
一个类可以定义多个不同的构造器，即构造器重载
构造器名和类名要相同
构造器没有返回值
构造器是完成对象的初始化，井不是创建对象
在创建对象时,系统自动的调用该类的构造方法
如果没有定义构造器，系统会自动给类生成一个默认无参构造器(默认构造器)

定义了自己的构造器,默认的构造器就覆盖了，就不能再使用默认的无参构造器，除非显式的定义一下

public class Constructor01 {
    public static void main(String[] args) {
        Pers p1 = new Pers();
        Pers p2 = new Pers("jack",80);
        System.out.println(p1.name+p1.age);
        System.out.println(p2.name+p2.age);
    }
}

class Pers{
    String name;
    int age;

    public Pers(){
        System.out.println("构造器1被调用");
        age = 18;
    }
    public Pers(String pName,int pAge){
        System.out.println("构造器2被调用");
        name = pName;
        age = pAge;
    }
}

6.9 this

基本介绍：

java虚拟机会给每个对象分配this，代表当前对象
内存分析：

注意事项和细节：

this关键字可以用来访问本类的属性、方法、构造器
this用于区分当前类的属性和局部变量
访问成员方法的语法：this.方法名(参数列表);
访问构造器语法：this(参数列表)：注意只能在构造器方法中使用(在构造器中访问另外一个构造器，必须放在第一条语句)
this不能在类定义的外部使用，只能在类定义的方法中使用

public class ThisExercise01 {
    public static void main(String[] args) {
        person p1 = new person("marry",20);
        person p2 = new person("marry",20);
        System.out.println(p1.compareTo(p2));
    }
}

class person{
    String name;
    int age;

    public person(String name,int age){
        this.name = name;
        this.age = age;
    }

    public boolean compareTo(person p){
        return this.name.equals(p.name) && this.age == p.age;
    }
}