100天精通Java (基础篇) —面向对象编程1.0【Java分水岭】

最新推荐文章于 2024-04-01 11:14:08 发布

竹本实

最新推荐文章于 2024-04-01 11:14:08 发布

阅读量475

点赞数

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

本文链接：https://blog.csdn.net/weixin_49667274/article/details/124206333

版权

Java基础专栏收录该内容

27 篇文章 1 订阅

订阅专栏

一、类与对象

1、养猫问题

张老太养了两只猫：一个名字叫小白，今年3岁，白色。还有一个叫小花，今年10岁，花色。编写一个程序，当用户输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果用户输入的小猫名字错误，则显示：张老太没有这只猫。

2、使用之前学的技术解决

1）单独的定义变量解决

2）使用数组解决

3、之前技术解决的缺点分析

不利于数据的管理

效率低

引出新知识点===》类与对象 (OOP)

4、代码

public class carOne {
    public static void main(String[] args) {
        Cat cat1 = new Cat();
        cat1.name = "小白";
        cat1.age = 3;
        cat1.color = "白色";

        Cat cat2 = new Cat();
        cat2.name = "小花";
        cat2.age = 10;
        cat2.color = "花色";

        System.out.println("第一只猫的信息：" + cat1.name + " " + cat1.age + " " + cat1.color);
        System.out.println("第二只猫的信息：" + cat2.name + " " + cat2.age + " " + cat2.color);

    }
}

class Cat {
    String name;
    int age;
    String color;
}

5、对象[属性，行为]

一个程序就是一个世界，有很多事物

6、类与对象的关系示意图

7、类与对象的区别和联系

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

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

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

8、对象在内存中存在形式（重点）

9、属性、成员变量、字段

基本介绍

1）从概念或叫法上看：成员变量 = 属性 = 字段

即成员变量是用来表示属性的

属性可以是基本数据类型，也可以是引用数据类型（对象，数组）

class Cat {
    String name;
    int age;
    String color;
    String[] master;
}

2）属性是类的一个组成部分，一般是基本数据类型，也可以是引用数据类型（对象，数组）

## 注意事项和细节说明

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

有四种访问修饰符 public，protected，默认，private

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

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

二、创建对象

1、如何创建对象

1）先声明再创建

Cat cat;//声明对象 cat

cat = new Cat();//创建

2）直接创建

Cat cat = new Cat();

2、如何访问属性

1）基本语法

对象名.属性名；

案例演示赋值和输出

cat.name;
cat.age;
cat.color;

2)类和对象的内存分配机制（重点）

看如下代码实例

Person p1 = new Person();
p1.age = 10;
p1.name = "小明";
Person p2 = p1;
System.out.println(p2.age);

p2.age输出多少？画出内存图

3、类和对象的内存分配机制

## Java内存的结构分析

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

2）堆：存放对象、数组等

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

4）示意图

## Java创建对象的流程简单分析

Person p = new Person();
p.name = "Jack";
p.age = 10;

1)先加载Person类信息（属性和方法信息，只会加载一次）

2）在堆中分配空间，进行默认初始化

3）把地址赋给 p, p 就指向对象

4）进行指定初始化，比如p.name = "Jack" p.age = 10;

看如下代码，进行分析

Person a = new Perosn();
a.age = 10;
a.name = "小明";
Person b = new Person();
b = a;
System.out.println(b.name);//小明
b.age = 20;
b = null;
System.out.println(a.age);//20
System.out.println(b.age);//异常

4、成员方法

1）基本介绍

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

2）成员方法快速入门

添加speak成员方法，输出“我是一个好人”

添加cal01 成员方法，可以计算从1+...+1000的结果

添加cal02 成员方法，该方法可以接收一个数 n，计算从1+...+n的结果

添加getSum 成员方法，可以计算两个数的和

代码：

import java.util.Scanner;
public class Method01 {

    public static void main(String[] args) {
        Person p = new Person();
        p.speak();
        p.cal01();
        System.out.println("请输入需要进行叠加计算的数：");
        Scanner myScanner = new Scanner(System.in);
        int n = myScanner.nextInt();
        p.cal02(n);
        System.out.println("请输入要进行相加的两个数字：");
        Scanner myScanner1 = new Scanner(System.in);
        Scanner myScanner2 = new Scanner(System.in);
        int num1 = myScanner1.nextInt();
        int num2 = myScanner2.nextInt();
        int sum = p.getSum(num1,num2);
        System.out.println("两数之和为："+ sum);
    }
}

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("cal01方法 计算结果是" + res);
    }

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

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

3）方法的调用机制原理：（重点-示意图）

4）为什么需要成员方法

看一个需求：

请遍历一个数组，输出数组的各个元素值。

解决思路1：传统方法，使用单个for循环，将数组输出

解决思路2：定义一个类MyTools，然后写一个成员方法，调用方法实现

public class Method02 {
    public static void main(String[] args) {
        int[][] map = {{0,0,0},{1,1,1},{2,2,2}};
        Mytools a = new Mytools();
        a.printArr(map);
    }
}

class Mytools{
    public void printArr(int[][] map){
        for (int i = 0; i < map.length; i++){
            for (int j = 0; j <map[i].length; j++){
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
    }
}

5）成员方法的好处

1、提高代码的复用性

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

6）成员方法的定义

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

语句；

return 返回值；

}

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

4、返回数据类型：表示成员方法输出， void 表示没有返回值

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

6、return 语句不是必须的

7)注意事项和使用细节

##访问修饰符：

如果不写访问修饰符，默认访问【具体有四种访问修饰符：public,protected,private,默认】

##返回值类型：

1）一个方法最多有一个返回值（若需要返回多个返回值，则可以返回数组）

2）返回类型可以为任意类型，包括基本数据类型和引用数据类型（数组、对象）

3）如果方法要求有返回值类型，则方法主体最后要有 return 值，而且要求返回值类型必须和return 值类型一致或者兼容

4）如果方法是void，可以没有return 语句，或者只写 return；

## 方法名

遵循驼峰命名法，最好见明知义，表达出该功能的意思

##形参列表

1）一个方法可以有零个形参，也可以有多个形参，中间用逗号隔开例如:public void getSum(int num1, int num2)

2)形参类型可以为任意数据类型，包括基本数据类型和引用数据类型（对象，数组）

3）调用带参数的方法时，要对应传入相同类型或者兼容类型的参数

4）方法定义时的参数称为形式参数，简称形参；方法调用时的参数称为实际参数，简称实参，形参和实参的类型要一致或者兼容，个数，顺序也必须一致。

##方法体

里面写实现功能的具体的语句，可以为输入、输出、变量、运算、分支、循环、方法调用、但方法里不能再定义方法，即方法不能嵌套定义

##方法调用小细节说明

1）同一类的方法可以直接调用

2）跨类中的方法A类调用B类中的方法，需要通过对象名调用，比如：对象名.方法名(参数)

3）特别说明：跨类调用方法时和方法的访问修饰符有关

##练习题：

1) 编写类 AA ，有一个方法：判断一个数是奇数 odd 还是偶数, 返回 boolean

import java.util.Scanner;
public class Exercise01 {
    public static void main(String[] args) {
        //1) 编写类 AA ， 有一个方法： 判断一个数是奇数还是偶数,
        // 返回 boolean
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入要判断奇偶的数字：");
        int n = myScanner.nextInt();

        AA a = new AA();
        if (a.judgeParity(n)){
            System.out.println("该数字为偶数");
        }else {
            System.out.println("该数字为奇数");
        }
    }
}

class AA{
    public boolean judgeParity(int n){
        if (n % 2 == 0){
            return true;
        }else{
            return false;
        }
    }
}

2) 根据行、列、字符打印对应行数和列数的字符，比如：行： 4，列： 4，字符#,则打印相应的效果

import java.util.Scanner;
public class Exercise01 {
    public static void main(String[] args) {
//2) 根据行、 列、 字符打印 对应行数和列数的字符，
 比如： 行： 4， 列： 4， 字符#,则打印相应的效果
        

        System.out.println("请输入一个字符： ");
        char n = myScanner.next().charAt(args.length);
        System.out.println("请输入行数：");
        int row = myScanner.nextInt();
        System.out.println("请输入列数：");
        int col = myScanner.nextInt();

        AA b = new AA();
        b.print(row, col, n);
    }
}

class AA{
    public boolean judgeParity(int n){
        if (n % 2 == 0){
            return true;
        }else{
            return false;
        }
    }
    public void print(int row, int col, char n){
        for (int i = 1; i < row; i++){
            for(int j = 1; j < col; j++){
                System.out.print(n);
            }
            System.out.println();
        }
    }
}

4)成员方法传参机制（重点）

1）基本数据类型的传参机制

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

2）引用数据类型的传参机制

应用类型传递的是地址（传递的也是值，但只是地址），可以通过形参改变实参

5）成员方法的返回值是引用类型

克隆对象

public class CopyPerson {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "Jack";
        p1.age = 10;
        MyTools Tool = new MyTools();
        Person p2 = Tool.copyPerson(p1);
        System.out.println(p2.age+" "+p2.name);
    }
}

class Person{
    String name;
    int age;
}

class MyTools{
    public Person copyPerson(Person p1){
        Person p2 = new Person();
        p2.age = p1.age;
        p2.name = p1.name;
        return p2;
    }
}

未完......