java入门总结---第三部分：函数、数组和面向对象简单了解

本文链接：https://blog.csdn.net/luohzzz/article/details/119114910

一、函数(基础重点)

1、基本了解

概念：实现特定功能的代码组成的一个整体；可以通过名字反复使用。
函数的应用流程：
① 函数的定义：确定函数的功能及函数名。
函数的声明：对函数起名并且声明此函数的功能。
函数的实现：如何实现函数对应的功能
② 函数的使用：通过函数名使用函数的功能称为函数的调用。
位置：定义在类以内，与main函数并列的位置(其他函数的外面)。

2、函数的定义

public class function{
	public static void main(String[] args) {
		//调用语法时
		函数名(参数);
	}
	public static void 函数名(参数){
		函数主体;
	}
}

public class function {
    public static void main(String[] args) {
        luo();
    }
    public static void luo(){
        System.out.println("你好");
    }
}
//结果：你好

3、函数的调用

函数名(参数);

多级调用

public class function{
	public static void main(String[] args){
		函数名1();
	}
	public static void 函数名1(){
		函数名2()
	}
	public static void 函数名2(){
		函数主体;
	}
}
//有返回值的函数的调用：
//数据类型 变量名 = 函数名(实际参数);

4、函数的作用

减少代码的冗余
提高的复用性
提高的可维护性
方便分工合作

5、递归

概念：在一个函数的内部调用它自身。
注意：开发时，避免无穷递归的现象；需要给递归设置出口。

二、数组（基础重点）

1、概念：可以同时存储多个相同类型的数据，并可以对数组中的数据进行统一操作。
2、数组的声明和赋值（定义）

数据类型[] 数组名; 数组名 = new 数据类型[长度];
int[] a1;
a1 = new int[5];
a1[0] = 1;
a1[1] = 2;
a1[2] = 3;
a1[3] = 4;
a1[4] = 5;

数据类型[] 数组名 = new 数据类型[长度];
int[] a2 = new int[5];
a2[0] = 1;
a2[1] = 2;
a2[2] = 3;
a2[3] = 4;
a2[4] = 5;

数据类型[] 数组名 = new 数据类型[] {value1, value2, …};
int[] a3 = new int[]{1,2,3,4,5};

数据类型[] 数组名 = {value1, value2, …};
int[] a4 = {1,2,3,4,5};
System.out.println(a4[1]);//结果是：2

3、用for进行数组遍历

int[] a = new int[2];
a[0] = 1;
a[1] = 2;
for (int i = 0; i < a.length; i++) {
	System.out.println(a[i]);
}
//结果：1
//     2

4、数组排序

冒泡法：相邻的两个数值比较大小，互换位置
选择法：固定值与其他值依次比较大小，互换位置
JDK排序法：java.tuil.Arrays.sort

冒泡法

for(int i=1;i<a.length;i++){
	for(int j=0;j<a.length-i;j++){
		if(a[j]>a[j+1]){
			int t = a[j];
			a[j]= a[j+1];
			a[j+1]=t;
		}
	}
}

选择法

for(int i=0;i<a.length-1;i++){
	for(int j=i+1;j<a.length;j++){
		if(a[i]>a[j]){
			int t= a[i];
			a[i]=a[j];
			a[j]=t;
		}
	}
}

5、二维数组的定义

数据类型[][] 数组名; 数组名 = new 数据类型[高维长度][低维长度];
int[][] a1;
a1 = new int[3][6];
a1[0][0] = 10;
a1[0][1] = 50;
a1[1][2] = 20;
a1[1][3] = 30;
a1[2][4] = 40;
a1[2][5] = 60;

数据类型[][] 数组名 = new 数据类型[高维长度][低维数组];
int[][] a2 = new int[3][6];
a2[0][0] = 10;
a2[0][1] = 50;
a2[1][2] = 20;
a2[1][3] = 30;
a2[2][4] = 40;
a2[2][5] = 60;

数据类型[] 数组名 = {{v1,v2,v3},{v4,v5},{v6}}; //这种好理解也好编码
int[][] a3 = {{1,2,3},{4,5},{6}};
System.out.println(a3[0][1]);//结果是：2

三、面向对象（重点）

1、简单了解对象

概念：客观复杂的事物在Java程序中的一种表象形式。(一切客观事物皆是对象，万物皆对象万物皆对象)
对象的组成：
① 对象的属性：代表对象有什么的特征(体现对象的静态部分-变量展现)
② 对象的方法：代表对象有什么样功能(体现对象的动态部分-方法展现)
类对象的关系：
① 类是对象的模板
② 对象是类的实例(对象根据类创造)

2、简单了解类

属性：代表对象有什么特征
① 属性又称为成员变量
② 位置：定义在类以内，方法以外
③ 语法：数据类型属性名;
数据类型属性名 = 值;
④ 注意：定义属性时，只需保留程序所关注的部分。
⑤ 成员变量具有默认值，默认值同数组
类与对象的关系：
类：定义了对象具有的特征和行为，类是对象的模板
对象：拥有多个特征和行为的实体，对象是类的实例

public class function{
	public static void main(String[] args){
		myClass myClass = new myClass();
		myClass.eat();//结果是：罗睡了
	}
}
//下面这里的整个就是一个类，里面的多个特征和行为就是对象
class myClass{
	String name = "罗";
	int age = 22;
	public void eat(){
		System.out.println(this.name+"睡了");
	}
}

3、this 的使用(重点理解)

第一种应用：this.
① this 代表当前对象，类似于"我"，this. 用在类中的成员方法或是构造方法中，调用 当前对象的属性或是成员方法
② this.属性名：代表调用当前对象的属性
this.方法名(实参)：代表调用当前对象的成员方法
③ this. 通常可以省略，但是当成员变量和局部变量命名冲突时，必须使用 this. 区分成员变量
！！注意点！！

public class function{
	public static void main(String[] args){
		myName myName = new myName();
		myName.sayHi();//结果是：xiaozhao
					   //		xiao
	}
}
class myName{
    String name = "xiao";
    public void sayHi(){
        String name = "xiaozhao";
        System.out.println(name);
        System.out.println(this.name);
        
    }
}

第二种应用：this()
① this():用在本类的构造方法中，调用本类其他构造方法。
② this():代表调用无参数的构造方法
this(实参)：调用有参数的构造方法
③ this()的应用必须是构造方法中第一行有效语句
④ 注意：使用 this()/this(实参)时，避免递归调用(回环调用)现象

class myThis{
    String name;
    int age;
    String sex;
    double score;
    
    public myThis(String name,int age,String sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    
    public myThis(String name,int age,String sex,double score){
        this(name,age,sex);
        this.score = score;
    }
}