java_oop_方法1

方法

方法概念
　　封闭业务逻辑
　　提高代码复用
定义类的方法
    类的方法定义类的某种行为(或功能)
    方法返回的数据类型    方法的名称 (方法的参数也叫形参)    {方法的主体}
    方法的命名
        用动词
方法的声明语法
　　方法的返回值
　　　　有返回值，须用return返回该值，返回类型为该值的类型
　　　　无返回值，返回类型为void
无参方法的调用
    方法之间允许互相调用，不需要知道方法的具体实例，提高了效率

package com.fgy.eclipse;

public class StudentTest {

    public static void main(String[] args) {
        Student s1=new Student();
        s1.name="张";
        s1.age=26;
        s1.gender='v';
        
        System.out.println(s1.getName());
        System.out.println(s1.getAge());
        System.out.println(s1.getGender());
        System.out.println(s1.comp());
        
        
    }

}

class Student {
    String name;
    int age;
    char gender;
    int sum=0;
    
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public char getGender() {
        return gender;
    }
    public int comp(){
        for (int i = 0; i < 7; i++) {
            if (i%2!=0) {
                sum+=i;
            }
        }
        return sum;
    }
}

 

带参方法的声明与调用
    <访问修饰符>返回类型<方法名>(形参){方法体}
    方法之间的调用
    在同一个类中静态方法（因为主方法是一个静态方法）不能直接调用非静态方法与非静态的属性的

形参与实参的概念
    定义时的声明叫做形参
    引用调用时传入的参数叫做实参

package com.fgy.java8se;


public class Demo1 {
    /**
     * 计算两个整数之和,带参数的方法
     * @return
     */
    //下面两个参数num1和num2是形参
    //形参与实参的数据类型要匹配，而名称可以不一样
    int add(int a,int b){
        return a+b;
    };
    
    //上面的是基本类型作为形参，引用类型也可以作为形参来引入
    /**
     * 计算两个数组的长度之和
     * @return
     */
    static int getLength(int[] a,int[] b){
        
        //加入了对null的校验,在实际中叫做参数的效性验证(校验)
        int length1=0,length2=0;
        if (a!=null) {
            length1=a.length;
        }
        if (b!=null) {
            length2=b.length;
        }
        //return a.length+b.length;
        return length1+length2;
    }
    
    //在同一个类中静态方法（因为主方法是一个静态方法）不能直接调用非静态方法与非静态的属性的
    public static void main(String[] args) {
        Demo1 sum=new Demo1();
        //将实参传入
        //int result=sum.add(33, 22);
        //System.out.println(result);
        
        
        //另外一种传参,下面两个num1和num2是局部变量
        int num1=20;
        int num2=30;
        int result=sum.add(num1,num2);
        System.out.println("结果："+result);
        
        result=Demo1.getLength(new int[]{2,3},new int[]{1,2,3});
        
        int[] num3={2,3},num4={1,2,3};
//        int result1=Demo1.getLength(num3, num4);
        int result1=Demo1.getLength(null, null);
        System.out.println("长度："+result1);
    }
}

方法的应用举例
    都会用带参的方法实现
    1计算一个整形数组的元素之和
    2将数组的奇数位的元素存入数组并返回
    3判断一个字符串是否在一个字符串数组中

1计算一个整形数组的元素之和
package com.fgy.java8se;

public class Demo2 {
    //先要构思方法是如何达到要求的，还要严谨，对null的校验之类，就是要严密些，不要有漏洞
    int getTotal(int[] nums) {
        if (nums == null) {
            return 0;
        }
        int total = 0;
        for (int i : nums) {
            total += i;
        }
        return total;
    }

    public static void main(String[] args) {
        int[] nums={1,2,3};
        Demo2 de=new Demo2();
        int total=de.getTotal(nums);
        //传入空参数的情况，要考虑进去
        //int total=de.getTotal(null);
        System.out.println(total);
    }
}

2将数组的奇数位的元素存入数组并返回
package com.fgy.java8se;

public class Demo3 {

    static int[] getPart(int[] nums){
        if (nums==null) {
            return null;
        }
        //下面的可读性较差
        //int[] result=new int[nums.length%2==0?nums.length/2:nums.length/2+1];
        //用下面这个代替
        int length=nums.length/2;
        if (nums.length%2==1) {
            length++;
        }
        int[] result=new int[length];
        for (int i = 0; i < result.length; i++) {
            result[i]=nums[i*2];
        }
         return result;
    }
    public static void main(String[] args) {
        int[] nums={1,2,3,4,5,6,7,8,9,10};
        int[] partData=Demo3.getPart(nums);
        for (int data : partData) {
            System.out.println(data);
        }
    }
}

3判断一个字符串是否在一个字符串数组中
package com.fgy.java8se;

public class Demo4 {

    //这个案例更实用
    /**
     * 
     * @param s
     * @param ss
     * @return true:存在，false:不存在
     */
    static boolean isExist(String s,String[] ss){
        if (ss==null) {
            return false;
        }
        for (String string : ss) {
            //要加入对空的判断(校验)，以免漏洞，不严密，避免bug
            if (s==null) {
                if (string==null) {
                    return true;
                }
            }else {
                if (s.equals(string)) {
                    return true;
                }
            }
        }
        return false;
    }
    public static void main(String[] args) {

        String s="cs";
        String[] ss={"cs","abc","de","ow"};
//        boolean b=Demo4.isExist(s, ss);
        boolean b=Demo4.isExist(null, ss);
        System.out.println(b);
    }
}

可变长度参数
    如何声明
        在参数类型后面使用三个点来表示
        只允许出现一个可变长度参数
        可变长度参数要出现在参数列表的最后
    如何调用

    允许方法接收个数不定的参数，是java5中引入的语法
　　该方法的实际参数可以是1.不传任何参数,2.传入一个，3.传入若干，4.传入一个数组。
    也可以将主方法的String[]数组，改为String...为可变长度参数。
    public static void main(String[] args)

package com.fgy.java8se;

public class Demo5 {
    
    //如果有多个参数的话，很不方便
//    int getTotal(int num1,int num2,int num3){
//        return num1+num2+num3;
    
    //用可变长参数解决
    int getTotal(int... num1){
        //针对空参数的处理
        if (num1==null) {
            return 0;
        }
        
        int total=0;
        for (int i = 0; i < num1.length; i++) {
            total+=num1[i];
        }
        return total;
    }
    public static void main(String[] args) {
        Demo5 vDemo5=new Demo5();
        //传一个或多个参数
        int result= vDemo5.getTotal(33,44);
        System.out.println(result);
        //不传参数
        result= vDemo5.getTotal();
        System.out.println(result);
        //传空参数，会报错，所以在方法里加入了相关代码
        result= vDemo5.getTotal(null);
        System.out.println(result);        
        //直接将数组传入
        int[] nums={2,3,4};
        result=vDemo5.getTotal(nums);
        System.out.println(result);
    }
}

命令行参数，实用性不太强
    使用命令行编译和运行包中的类
    main方法详解
    什么是命令行参数
    命令行参数的使用
    
    1先进入源码根目录
    2javac com/fgy/java8s1/Hello.java
    3java com.fgy.java8s1.Hello

    main方法是程序的入口，由jvm调用
    可以有多个main方法，可以当成类的普通方法
    不是每个类都有main方法，最终只有一个
package com.fgy.java8se;

public class Demo6 {

    //可以有多个主方法
    public static void main(String[] args) {
    }
    //普通的主方法
    void main(){
        System.out.println("main");
    }
}

    在jvm调用main方法时，传入到该方法中的参数就叫命令行参数
    
    public static void main(String[] args) {
        for (String string : args) {
            System.out.println(string);
        }
    }
    
    针对上面的代码，分别用命令行与ide工具传入参数
    命令行传参数
    java com.fgy.java8s1.Hello abc cde 123
    
    eclipse中传参数，在java源文件中右击，run configuration
    传普通参数，用空格或换行分隔，
    传*参数，需要这样aa " * " bb,星号前后有空格。这样就将3个参数传入。