java 9. 面向对象之方法设计

**类中的方法 ---- > 做一件事情

描述一个方法
权限修饰符 [特征修饰符] 返回值类型 方法名字 (参数列表) [抛出异常] [{
	方法体
}]

必须有的结构
权限修饰符 返回值类型 方法名字 () {
	
}



1. 无参数无返回值
2. 无参数有返回值
3. 有参数无返回值
4. 有参数有返回值

Person.java

public class Person {
    public String name;
    public int age;
    public String sex;

    // 无参数无返回值
    public void eat(){
        System.out.println("吃了一碗大米饭");
    }
    //无参数有返回值
    public String tellName(){
        return "Java";
    }
    //无参数有返回值
    public void newEat(int count,String sth){
        System.out.println("吃了"+count+"碗"+sth);
    }
    //有参数有返回值
    public String buyDrink(int money){
        if(money>5){
            return "红牛";
        }else{
            return "矿泉水";
        }
    }

Test.java

import com.sun.prism.shader.Solid_ImagePattern_Loader;

public class Test {
    public static void main(String[] args) {
        //方法
        // 无参数无返回值
        Person p = new Person();
//        p.eat();
//        p.name = "test";
        //无参数有返回值
//        String myName = p.tellName();
//        System.out.println("接收到了tellName方法的返回值："+myName);
        //有参数无返回值
        //p.newEat(3,"过桥米线");
        //有参数有返回值
        String buyD = p.buyDrink(10);
        System.out.println("我买了一瓶"+buyD);

        // 属性
//        Person p = new Person();
//        System.out.println(p.name);
//        p.name = "吸溜";
//        p.age = 18;
//        p.sex = "男";
//        System.out.println(p.name+"今年"+p.age+"岁，性别是"+p.sex);
//        Person p2 = new Person();
//        Person p1 = p;
//        p1.name = "小姐姐";
//        p1.age = 16;
//        p1.sex = "女";
//        System.out.println(p.name+"今年"+p.age+"岁，性别是"+p.sex);
//        System.out.println(p1.name+"今年"+p1.age+"岁，性别是"+p1.sex);

    }
}

练习题

设计一个方法，用来画星星，倒三角行数不确定，方向不确定

****
***
**
*

****
 ***   
  **
   *

空格0，1，2，3
*  4，3，2，1

-- 方法

public class Person {
    //画星星
    //f：true 偏左 没空格，false 偏右 带空格
    public void drawStar(int line,boolean f){
        for(int i=1;i<=line;i++){
            if(!f){
                for(int j=1;j<=line-i;j++){
                    System.out.print(" ");
                }
            }
            for(int j=1;j<=i;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

--main

package method_one;

public class Test {
    public static void main(String[] args) {
        //画星星
        p.drawStar(4,false);
    }
}

设计一个方法，用来交换两个数组元素a{1,2,3,4} b{5,6,7,8}

import java.util.Arrays;

public class Demo {
    //设计一个方法，用来交换两个数组元素a{1,2,3,4}  b{5,6,7,8}
    public int[][] ArrNumjiaohuan(int[] a, int[] b){
        //将两个数组的地址引用直接互换
        int[] temp = a;
        a = b;
        b = temp;
        int[][] result = {a,b};
        return result;
    }


    public static void main(String[] args) {
        Demo p = new Demo();
        //设计一个方法，用来交换两个数组元素a{1,2,3,4}  b{5,6,7,8}
        int[] arra={1,2,3,4};
        int[] arrb={5,6,7,8,9};
        int[][] value = p.ArrNumjiaohuan(arra,arrb);
        arra = value[0];
        arrb = value[1];
        System.out.println(Arrays.toString(arra));
        System.out.println(Arrays.toString(arrb));
    }
}

设计一个方法，用来交换一个数组头尾互换

import java.util.Arrays;

public class Demo {
    public static void arrHeaderEndChange(int[] args){
        System.out.println(Arrays.toString(args));
        for(int i=0;i<args.length/2;i++){
            int x = args[i];
            args[i] = args[args.length-1-i];
            args[args.length-1-i] = x;
        }
        System.out.println(Arrays.toString(args));
    }
}

设计一个方法，用来寻找数组中的极值(最大最小值)

public class Demo{
    //给我一个数组，告诉我找最大值还是最小值，flag=false就找最小值，true找最大值
    public int findMaxOrMinNum(int[] array,boolean flag){
        int result = array[0];
        for(int i=1;i<=array.length-1;i++){
            if(flag && result<array[i]){
                result = array[i];
            }else if(!flag && array[i]<result){
                result = array[i];
            }
        }
        return result;
    }
}

public class Test{
    public static void main(String[] args){
        Demo d = new Demo();
        int[] arr = {2,4,6,8,0,9,1,3,5,7};
        int result = d.findMaxOrMinNum(arr,false);
        System.out.println(result);
    }
}

设计一个方法，用来找寻给定的元素是否在数组内存在

public class Demo {
    public String findNumExist(int[] array,int target){
        String result = "你输入的值"+target+"在数组中没有"; //编译检测的悲观性原则
        for(int i=0;i<=array.length-1;i++){
            if(target==array[i]){
                result = "恭喜，你输入的值在数组中存在";
                break;
            }
        }
        //执行for循环遍历完数组的所有元素都没有进入到if，就是不存在
        return result;
    }
}

public class Test {
    public static void main(String[] args){
        Demo d = new Demo();
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        System.out.println(d.findNumExist(arr,100));
    }
}

设计一个方法，用来合并两个数组

public class Demo{
    public int[] mergeArr(int[] a,int[] b){
        int[] bigArr = new int[a.length+b.length];
        for(int i=0;i<a.length;i++){
            bigArr[i] = a[i];
        }
        for(int i=0;i<b.length;i++){
            bigArr[a.length+i] = b[i];
        }
        return bigArr;
    }
}

import java.util.Arrays;
public class Test{
    public static void main(String[] args){
        Demo d =new Demo();
        int[] a = {1,2,3,4};
        int[] b = {5,6,7,8,9,0};
        System.out.println(Arrays.toString(d.mergeArr(a,b)));;
    }
}

设计一个方法，用来将一个数组按照最大值位置拆分

public class Demo{
public int[][] splitArr(int[] a){
        int max = a[0];
        int index = 0;
        for(int i=0;i<a.length;i++){
            if(a[i]>max){
                max = a[i];
                index = i;
            }
        }
        System.out.println("最大值的索引是："+index);
        int[] newa = new int[index];
        int[] newb = new int[a.length-index-1];
        for(int i=0;i<newa.length;i++){
            newa[i] = a[i];
        }
        for(int i=0;i<newb.length;i++){
            newb[i] = a[index+1+i];
        }
//        int[][] result = {newa,newb};
//        return result;
        return new int[][]{newa,newb};
    }
}

import java.util.Arrays;
public class Test{
    public static void main(String[] args){
        Demo d = new Demo();
        int[] arr = {1,2,3,4,5,90,6,7,8};
        int[] a = d.splitArr(arr)[0];
        int[] b = d.splitArr(arr)[1];
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.toString(b));
    }
}

设计一个方法，用来去掉数组中的0元素

public class Demo{
    public int[] delArrZeroNum(int[] array){
        //找出非0元素个数
        int count = 0;
        for(int i=0;i<array.length;i++){
            if(array[i]!=0){
                count++;
            }
        }
        int[] newa = new int[count];
        int index = 0;
        for(int i=0;i<array.length;i++){
            if(array[i]!=0){
                newa[index++] = array[i];
            }
        }
        return newa;
    }
}

import java.util.Arrays;
public class Test{
    public static void main(String[] args){
        Demo d = new Demo();
        int[] arr = {1,2,3,0,0,4,5,0,6,0,7};
        System.out.println(Arrays.toString(d.delArrZeroNum(arr)));
    }
}

设计一个方法，用来存储给定范围内的素数(2-100)

public class Demo{
    public int[] arrPrime(int begin,int end){
        if(begin<0 || end<0){
            System.out.println("输入的范围不能为负数");
            return null;
        }
        if(begin>end){
            System.out.println("输入的范围不对，begin应该小于end");
            return null;
        }
        //创建一个足够大的数组存放非0元素
        int[] prime = new int[(end-begin)/2];
        int index = 0;
        for(int i=begin;i<=end;i++){
            boolean flag = false;
            for(int j=2;j<=i/2;j++){
                if(i%j==0){
                    flag = true;
                    break;
                }
            }
            if(!flag){
                prime[index] = i;
                index++;
            }
        }
        //将数组后面多余的0去掉
        int[] newPrime = new int[index];
        for(int i=0;i<prime.length;i++){
            if(prime[i]!=0){
                newPrime[i] = prime[i];
            }
        }
        return newPrime;
    }
}

public class Test{
    public static void main(String[] args){
        Demo d = new Demo();
        System.out.println(Arrays.toString(d.arrPrime(2，100)));
    }
}

设计一个方法，用来给数组元素排序(冒泡排序算法)--既能升序又能降序

public class Demo{
    public void bubble(int[] array,boolean flag){
        for(int i=0;i<array.length-1;i++){ //比较轮次为元素个数-1
            for(int j=array.length-1;j>0;j--){
                if((flag && array[j]<array[j-1])||(!flag && array[j]>array[j-1])){
                    int temp = array[j];
                    array[j] = array[j-1];
                    array[j-1] = temp;
                }
            }
        }
    }
}

public class Test{
    public static void main(String[] args){
        Demo d = new Demo();
        int[] arr = {10,5,2,3,1,4};
        d.bubble(arr,true);
        System.out.println(Arrays.toString(arr));
    }
}

设计一个方法，用来实现用户登录认证(二维数组当作小数据库)

posted @ 2022-04-05 19:07 我是一言阅读(27) 评论(0) 编辑收藏举报

刷新页面返回顶部

脚踏实地，仰望星空

我搬家了，以后主要在csdn记录，欢迎来https://blog.csdn.net/kpc0564335

java 9. 面向对象之方法设计

**类中的方法 ---- > 做一件事情

练习题

公告