Java基础——面向对象编程

weixin_50458070

已于 2023-10-19 09:32:38 修改

阅读量60

点赞数

分类专栏： Java基础文章标签： java

于 2023-04-27 21:42:12 首次发布

本文链接：https://blog.csdn.net/weixin_50458070/article/details/130415758

版权

Java基础专栏收录该内容

13 篇文章 0 订阅

订阅专栏

本文介绍了Java中的类与对象的概念，包括类作为抽象模板和对象作为实例的区别，对象在内存中的存储方式以及如何创建对象。接着讨论了成员方法，包括调用机制、好处、参数传递、递归调用、方法重载和可变参数。此外，还涉及了作用域、构造方法和this关键字的使用。

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

1、类与对象

1.1 类与对象的差异

1) 类是抽象的，概念的，代表一类事物 , 比如人类 , 猫类 .., 即它是数据类型 .

2) 对象是具体的，实际的，代表一个具体事物 , 即是实例 .

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

1.2 对象在内存中存在形式

1.3 对象的创建

先声明再创建

Cat cat ; // 声明对象 cat

cat = new Cat(); // 创建

直接创建：

Cat cat = new Cat();

1.4 Java内存结构分析

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

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

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

2 成员方法

定义：

访问修饰符返回数据类型方法名（形参列表 .. ） {// 方法体

语句；

return 返回值;

}

一个方法最多有一个返回值
返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值;
如果方法是 void，则方法体中可以没有 return 语句，或者只写 return ;

2.1 方法调用机制：

同一个类内的方法可以直接调用
不同类需要通过对象名来调用

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.say();
    }
}
class Cat{
    private String name;
    private int age;

    public void say(){
        System.out.println("芝芝在唱歌......");
    }
    private void sang(){
        say();
    }
}

2.2 成员方法好处：

1) 提高代码的复用性

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

2.3 成员方法传参机制

基本数据类型，传递的是值，形参的任何改变不影响实参

swap内的ab发生任何改变不影响main方法内的数值

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        //创建 AA 对象 名字 obj
        AA obj = new AA();
        obj.swap(a, b); //调用 swap
        System.out.println("main 方法 a=" + a + " b=" + b);//a=10 b=20
    }
}

class AA {
    public void swap(int a, int b) {
        System.out.println("\na 和 b 交换前的值\na=" + a + "\tb=" + b);//a=10 b=20
        //完成了 a 和 b 的交换
        int tmp = a;
        a = b;
        b = tmp;
        System.out.println("\na 和 b 交换后的值\na=" + a + "\tb=" + b);//a=20 b=10
    }
}

a 和 b 交换前的值
a=10 b=20

a 和 b 交换后的值
a=20 b=10
main 方法 a=10 b=20

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

public class Test {
    public static void main(String[] args) {
        //测试
        B b = new B();
        Person p = new Person();
        p.name = "jack";
        p.age = 10;
        b.test200(p);
        System.out.println("main 的 p.age=" + p.age);//10000
    }
}

class Person {
    String name;
    int age;
}

class B {
    public void test200(Person p) {
        p.name = "tom";
        p.age = 99;
    }
}

输出如下：

main 的 p.age=99

2.4 方法递归调用

2.5 方法重载

好处：

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

要求：

方法名必须相同
形参列表必须不同
返回类型无要求

    public void test(Integer num1) {
        System.out.println(num1);
    }   
    public Integer test(Integer num1,Integer num2) {
        return num1+num2;
    }

2.6 可变参数

java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。

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

}

public class Test {
    public static void main(String[] args) {
        B b = new B();
        System.out.println(b.test(1, 2, 3, 4));
    }
}


class B {

    public Integer test(Integer... nums) {
        int res = 0;
        for (int i = 0; i < nums.length; i++) {
            res += nums[i];
        }
        return res;
    }
}

10

可变参数的入参可为0或者任意多个，实质就是数值

2.7 作用域

全局变量：也就是属性，作用域为整个类
局部变量：除了属性之外的其他变量，作用域为定义他的代码块内

全局变量可以不赋值直接使用，存在默认值；局部变量无默认值，必须赋值以后才可以使用

class Cat {

    public String name;
    public Integer age;
    
    public void say(){
        String color;
        System.out.println(color);//报错
        System.out.println(age);
    }
}

局部变量与全局变量差异对比

同一作用域内，局部变量不可以重名；属性与局部变可以重名，访问时遵循就近原则
全局变量可以被其他类使用，局部变量只可以在当前方法内使用
全局变量可以加修饰符，局部变量不可以加修饰符
属性生命周期较长，伴随着对象的创建而创建，伴随着对象的摧毁而摧毁。局部变量生命周期较短，伴随代码块执行而创建，代码块的结束而摧毁、

·2.8 构造方法/构造器

基本语法：

[ 修饰符 ] 方法名 ( 形参列表 ){

方法体;

}

特点

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

注意事项：

一个类可以定义多个不同的构造器，即构造器重载
构造器是完成对象初始化，并不是创建对象
在创建对象时，系统自动调用该类的构造方法
如果没定义构造器，系统生成一个默认无参构造器；一旦定义了自己的构造器，默认构造器将会被覆盖

public class Test {
    public static void main(String[] args) {
        Cat cat1 = new Cat("yrh");
        Cat cat2 = new Cat(15);
        Cat cat3 = new Cat();//报错
    }
}

class Cat {

    public String name;
    public Integer age;

    public Cat(Integer age) {
        System.out.println(age);
    }

    Cat(String name) {
        System.out.println(name);
    }
}

2.9 this关键字

this：哪个对象调用，this就代表哪个对象

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat("yrh", 18);
        cat.info();
    }
}

class Cat {

    public String name;
    public Integer age;

    public Cat(String cName,Integer cAge) {
        name=cName;
        age=cAge;
    }

    public void info(){
        System.out.println(name+"\t"+age+"\t");
    }
}

yrh 18

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat("yrh", 18);
        cat.info();
    }
}

class Cat {

    public String name="yrh2";
    public Integer age=28;

    public Cat(String name,Integer age) {
        name=name;
        age=age;
    }

    public void info(){
        System.out.println(name+"\t"+age+"\t");
    }
}

yrh2 28

    public Cat(String name,Integer age) {
    //        就是当前对象的属性 name
        this.name=name;
    //        就是当前对象的属性 age      
        this.age=age;
    }