菜鸟学JAVA之——类、对象、方法

类、对象

万事万物皆对象

• 抽象：提取关键特征形成模板

• 类：所有相似对象，关键特征的集合

• 很多个对象中具有相同的属性和方法时，我们就可以将其抽象成类

• 类中定义的属性不需要赋初值；

• 不同的场景对象抽象出的特征不一样

• 行为(方法)：一系列动作的集合，参数是方法的条件 ，结束的动作是得到一个结果

面向过程与面向对象的区别：

面向过程

面对过程编程，需要把过程描述的很详细

面向对象

放在方法里，对象学会了这个方法，控制对象就行了 【对象.方法(参数)；】
eg：搬宿舍
面向过程，一个一个地搬行李；
面向对象，打包好，调用人来搬。

方法（把相同相似的过程包裹起来）

方法不能声明在方法体中

格式

访问控制 [static] 返回值类型 方法名 ( 参数列表 ) { 方法体 }

public static int[] sort(int[] args){

//方法体

[return[返回值];]

}

eg：现在需要给两个数组进行排序

代码示例

import java.util.*;
public class Sort{
    public static void main(String[] args){
        int[] arrays1 = {55,78,33,26,42,99,102,50,4};
        int[] arrays2 = {5,8,3,44,56,22,10,123,222,32}; 
        //arrays1排序
        for(int i = 0; i < arrays1.length; i++){
            for(int j = i; j > 0;j--){
                if(arrays1[j] < arrays1[j-1]){
                    int temp = arrays1[j];
                    arrays1[j] = arrays1[j-1];
                    arrays1[j-1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arrays1));
         //arrays1排序
        for(int i = 0; i < arrays2.length; i++){
            for(int j = i; j > 0;j--){
                if(arrays2[j] < arrays2[j-1]){
                    int temp = arrays2[j];
                    arrays2[j] = arrays2[j-1];
                    arrays2[j-1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arrays2)); 
    }
}

那么问题来了，如果需要给100个数组排序，还需要写100遍排序算法吗？

这时发现每个排序大致都是一样的，有变化的只是数组的名称

所以将公共方法提取出来，打包成方法，这里就引入了方法

代码示例

import java.util.*;
public class Sort{//类名：大驼峰命名法
    public static void main(String[] args){
        int[] arrays1 = {55,78,33,26,42,99,102,50,4};
        int[] arrays2 = {5,8,3,44,56,22,10,123,222,32}; 
      	arrays1 = sort(arrays1); //调用sort方法给arrays1排序
        arrays2 = sort(arrays2); //调用sort方法给arrays2排序
        System.out.println(Arrays.toString(arrays1));               				System.out.println(Arrays.toString(arrays2));
    }
    //注意：方法不能声明在方法体中！
     public static int[] sort(int[] arr){ //方法名：小驼峰命名法
         for(int i = 0; i < arr.length; i++){
            for(int j = i; j > 0;j--){
                if(arr[j] < arr[j-1]){
                    int temp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = temp;
                }
            }
        }
        return arr;
     }
}

这时，如果需要给100个数组排序只需调用100次sort()方法即可，这就大大降低了代码的冗余度。

这里再说下方法中的一个特殊的形参——不定长参数集

public static void print(String... strs)
{
    for (int i = 0; i < strs.length; i++)   //获取长度的方式跟数组的一样
    {
        System.out.println(strs[i]);
    }
}

调用方法时，可以传任意多个参数，传之前并不需要定义他有多长。不定长参数集也可以不传参数
有几种形式：int… String… Object…(这个形式数为可以传任意类型任意多个参数)

举例来看一下

public class Test {
    void hit(String... name) {
    
	}
}

public class Main {
    public static void main(Stirng) {
        hit("zhangaoqi","zhangsan","lisi");  //正确
        hit();   //正确
        hit("wangwu"); //正确
    }
}

注意：如果要用String… arg（类似这样的不定长参数集） ，那一定要把他声明在末尾。且不定长参数集在方法的形参中，最多只能声明一个

void hit(String... a,String... b){}  //错误，因为传参时就不知道是给那个传了,无法区分
void hit(String.. a,int b ) //错误，如果String不传，只传一个int数字，也就错了
void hit(int a,String... b) //正确，可区分了

这个不定长参数集其实就是一个不定长的数组，可以把它当作数组来操作（jdk5.0之前没有不定长参数集，就是用数组来实现的）

public void show(String... arr) {
        for(int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

构造方法

作用：初始化对象

特点：

1. 无返回值
2. 方法名必须与类名相同
3. 在创建对象时一定调用构造方法
4. 在你未定义构造方法的时候系统会自动定义一个构造方法，如果你定义了构造方法，则此方法会覆盖掉系统自定义的方法

public class Person{
    String name;
    Person(){  //构造方法
        
    }
}

静态方法和动态方法的区别
动态方法：必须要有对象，才能调用
静态方法（static）：静态方法是可以直接调用的方法，不需要对象的调用