javase学习——面向对象（上）

最新推荐文章于 2024-09-03 16:55:43 发布

PorkPorkChop

最新推荐文章于 2024-09-03 16:55:43 发布

阅读量69

点赞数

文章标签：学习 java jvm

本文链接：https://blog.csdn.net/wangjiaju960914/article/details/126462027

版权

1. 面向对象编程

1.1 什么是类

类是一类具有相同特性的事物的抽象描述，是一组相关属性和行为的集合。
	- 属性：就是该事物的状态信息。
	- 行为：就是在你这个程序中，该状态信息要做什么操作，或者基于事物的状态能做什么。

1.2 什么是对象

即对象是类的一个实例，必然具备该类事物的属性和行为

1.3 如何定义类

【修饰符】 class 类名{

}

如：

public class Student{
    
}

1.4 对象的创建

new 类名()//也称为匿名对象

//给创建的对象命名
//或者说，把创建的对象用一个引用数据类型的变量保存起来，这样就可以反复使用这个对象了
类名 对象名 = new 类名();

2. 成员变量

2.1 声明成员变量

【修饰符】 class 类名{
    【修饰符】 数据类型  成员变量名; 
}

public class Person{
	String name;
    char gender;
    int age;
}

位置要求：必须在类中，方法外
类型要求：可以是Java的任意类型，包括基本数据类型、引用数据类型（类、接口、数组等）
修饰符：成员变量的修饰符有很多，例如：public、protected、private、static、volatile、transient、final等

2.2 对象的实例变量

实例变量的默认值

分类	数据类型	默认值
基本类型	整数（byte，short，int，long）	0
	浮点数（float，double）	0.0
	字符（char）	‘\u0000’
	布尔（boolean）	false
	数据类型	默认值
引用类型	数组，类，接口	null

3. 方法

3.1 方法的概念

方法也叫函数，是一组代码语句的封装，从而实现代码重用，从而减少冗余代码。
通常它是一个独立功能的定义，方法是一个类中最基本的功能单元。

3.2 方法的特点

	1. 先声明后使用
	2. 不调用不执行，调用一次执行一次

3.3 方法的声明

1. 声明的位置
类{
    方法1(){
        
    }
    方法2(){
        
    }
}

2. 声明方法的语法格式
【修饰符】 返回值类型 方法名(【形参列表 】)【throws 异常列表】{
        方法体的功能代码
}

4. 参数问题

4.1 可变参数

当定义一个方法时，形参的类型可以确定，但是形参的个数不确定，那么可以考虑使用可变参数。可变参数的格式：

【修饰符】 返回值类型 方法名(【非可变参数部分的形参列表,】参数类型... 形参名){  }

可变参数的特点和要求：

（1）一个方法最多只能有一个可变参数
（2）如果一个方法包含可变参数，那么可变参数必须是形参列表的最后一个
（3）在声明它的方法中，可变参数当成数组使用
（4）其实这个书写 “≈” 【修饰符】 返回值类型 方法名(【非可变参数部分的形参列表,】参数类型[] 形参名){  }

方法只有可变参数

package com.atguigu.test05.param;

public class NumberTools {
    int total(int[] nums){
        int he = 0;
        for (int i = 0; i < nums.length; i++) {
            he += nums[i];
        }
        return he;
    }

    int sum(int... nums){
        int he = 0;
        for (int i = 0; i < nums.length; i++) {
            he += nums[i];
        }
        return he;
    }
}

方法既有可变参数又有不可变参数

package com.atguigu.test05.param;

public class StringTools {
    String concat(char seperator, String... args){
        String str = "";
        for (int i = 0; i < args.length; i++) {
            if(i==0){
                str += args[i];
            }else{
                str += seperator + args[i];
            }
        }
        return str;
    }
}

4.2 参数的传递机制

1. 方法的形参是基本数据类型时，形参值的改变不会影响实参；
2. 方法的形参是引用数据类型时，形参地址值的改变不会影响实参，但是形参地址值里面的数据的改变会影响实参，例如，修改数组元素的值，或修改对象的属性值。

5. 重载（overload）

- 方法重载：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。
- 参数列表：数据类型个数不同，数据类型不同（按理来说数据类型顺序不同也可以，但是很少见，也不推荐，逻辑上容易有歧义）。
- 重载方法调用：JVM通过方法的参数列表，调用匹配的方法。
  - 先找个数、类型最匹配的
  - 再找个数和类型可以兼容的，如果同时多个方法可以兼容将会报错

6. 递归

方法自己调用自己的现象就称为递归。

// 计算斐波那契数列（Fibonacci）的第n个值，斐波那契数列满足如下规律，1,1,2,3,5,8,13,21,....
package com.atguigu.test07.recursion;

public class FibonacciTest {
    public static void main(String[] args) {
        FibonacciTest t = new FibonacciTest();
        //创建FibonacciTest的对象，目的是为了调用f方法

        for(int i=1; i<=10; i++){
            System.out.println("斐波那契数列第" +i +"个数:" + t.f(i));
        }

        System.out.println(t.f(20));//6765   
    }

    //使用递归的写法
    int f(int n){//计算斐波那契数列第n个值是多少
        if(n<1){//负数是返回特殊值1，表示不计算负数情况
            return 1;
        }
        if(n==1 || n==2){
            return 1;
        }
        return f(n-2) + f(n-1);
    }
}

7. 对象数组

1. 数组是用来存储一组数据的容器，一组基本数据类型的数据可以用数组装，那么一组对象也可以使用数组来装。
2. 即数组的元素可以是基本数据类型，也可以是引用数据类型。当元素是引用数据类型是，我们称为对象数组。

7.1 二维数组

二维数组：本质上就是元素为一维数组的一个数组。

int[][] arr; //arr是一个二维数组，可以看成元素是int[]一维数组类型的一维数组

1. 二维数组也可以看成一个二维表，行*列组成的二维表==，只不过这个二维表，每一行的列数还可能不同。但是每一个单元格中的元素的数据类型是一致的，例如：都是int，都是String等。
2. 二维数组也可以看成一个一维数组，只是此时元素是一维数组对象

7.2 二维数组的声明

元素的数据类型[][] 二维数组的名称;

public class Test20TwoDimensionalArrayDefine {
    public static void main(String[] args) {
        //存储多组成绩
        int[][] grades;

        //存储多组姓名
        String[][] names;
    }
}

7.3 二维数组的静态初始化

//以下格式要求声明与静态初始化必须一起完成
元素的数据类型[][] 二维数组的名称 = {
			{元素1，元素2，元素3 。。。}, 
			{第二行的值列表},
			...
			{第n行的值列表}
		};

元素的数据类型[][] 二维数组名 = new 元素的数据类型[][]{
			{元素1，元素2，元素3 。。。}, 
			{第二行的值列表},
			...
			{第n行的值列表}
		};

元素的数据类型[][] 二维数组名;
二维数组名 = new 元素的数据类型[][]{
			{元素1，元素2，元素3 。。。}, 
			{第二行的值列表},
			...
			{第n行的值列表}
		};

int[][] arr = {{1,2,3},{4,5,6},{7,8,9,10}};//声明与初始化必须在一句完成

	int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9,10}};

	int[][] arr;
	arr = new int[][]{{1,2,3},{4,5,6},{7,8,9,10}};

	arr = new int[3][3]{{1,2,3},{4,5,6},{7,8,9,10}};//错误，静态初始化右边new 数据类型[][]中不能写数字

7.4 二维数组的使用

1. 二维数组的长度/行数：二维数组名.length
2. 二维数组的某一行：二维数组名[行下标]，此时相当于获取其中一组数据。它本质上是一个一维数组。行下标的范围：[0, 二维数组名.length-1]。此时把二维数组看成一维数组的话，元素是行对象
3. 某一行的列数：二维数组名[行下标].length，因为二维数组的每一行是一个一维数组。
4. 某一个元素：二维数组名\[行下标\]\[列下标\]，即先确定行/组，再确定列。

public class Test22TwoDimensionalArrayUse {
    public static void main(String[] args){
        //存储3个小组的学员的成绩，分开存储，使用二维数组。
		/*
		int[][] scores1;
		int scores2[][];
		int[] scores3[];*/

        int[][] scores = {
                {85,96,85,75},
                {99,96,74,72,75},
                {52,42,56,75}
        };

        System.out.println(scores);//[[I@15db9742
        System.out.println("一共有" + scores.length +"组成绩.");

        //[[：代表二维数组，I代表元素类型是int
        System.out.println(scores[0]);//[I@6d06d69c
        //[：代表一维数组，I代表元素类型是int
        System.out.println(scores[1]);//[I@7852e922
        System.out.println(scores[2]);//[I@4e25154f
        //System.out.println(scores[3]);//ArrayIndexOutOfBoundsException: 3

        System.out.println("第1组有" + scores[0].length +"个学员.");
        System.out.println("第2组有" + scores[1].length +"个学员.");
        System.out.println("第3组有" + scores[2].length +"个学员.");

        System.out.println("第1组的每一个学员成绩如下：");
        //第一行的元素
        System.out.println(scores[0][0]);//85
        System.out.println(scores[0][1]);//96
        System.out.println(scores[0][2]);//85
        System.out.println(scores[0][3]);//75
        //System.out.println(scores[0][4]);//java.lang.ArrayIndexOutOfBoundsException: 4
    }
}

7.5 二维数组的遍历

for(int i=0; i<二维数组名.length; i++){ //二维数组对象.length
    for(int j=0; j<二维数组名[i].length; j++){//二维数组行对象.length
        System.out.print(二维数组名[i][j]);
    }
    System.out.println();
}

public class Test23TwoDimensionalArrayIterate {
    public static void main(String[] args) {
        //存储3个小组的学员的成绩，分开存储，使用二维数组。
        int[][] scores = {
                {85,96,85,75},
                {99,96,74,72,75},
                {52,42,56,75}
        };

        System.out.println("一共有" + scores.length +"组成绩.");
        for (int i = 0; i < scores.length; i++) {
            System.out.print("第" + (i+1) +"组有" + scores[i].length + "个学员，成绩如下：");
            for (int j = 0; j < scores[i].length; j++) {
                System.out.print(scores[i][j]+"\t");
            }
            System.out.println();
        }
    }
}