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

末蓝、 2023-05-30 09:10 63阅读 0赞

## [类、对象][Link 1] ##

万事万物皆对象  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lzZjE1NjA5MjYwODQ4_size_16_color_FFFFFF_t_70]

*  抽象：提取关键特征形成模板
 *  类：所有相似对象，关键特征的集合
 *  很多个对象中具有相同的属性和方法时，我们就可以将其抽象成类
 *  类中定义的属性不需要赋初值；
 *  不同的场景对象抽象出的特征不一样
 *  行为(方法)：一系列动作的集合，参数是方法的条件 ，结束的动作是得到一个结果

### [面向过程与面向对象的区别][Link 2]： ###

###### 面向过程 ######

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

###### 面向对象 ######

放在方法里，对象学会了这个方法，控制对象就行了 【对象.方法(参数)；】  
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）：静态方法是可以直接调用的方法，不需要对象的调用

[Link 1]: https://www.runoob.com/java/java-object-classes.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lzZjE1NjA5MjYwODQ4_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191108211619531.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lzZjE1NjA5MjYwODQ4,size_16,color_FFFFFF,t_70
[Link 2]: https://blog.csdn.net/xmh594603296/article/details/79774167