fivemethod

最新推荐文章于 2024-08-03 17:05:14 发布
最新推荐文章于 2024-08-03 17:05:14 发布
阅读量82 收藏
点赞数 2
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2406_85562971/article/details/140756585
版权 
 
    三要素:
        (1)方法名称:
        (2)是否有未知数据参加运算:
        (3)是否产生结果数据:

    方法不调用,不执行
        调用格式:
        	//把调用方法后,产生的结果数据赋值给左侧的变量
            数据类型 变量名称 = 方法名称(参数列表...);
 定义方法,判断一个字符是否是字母
}
public class Demo02DefineMethod {
    public static void main(String[] args) {
        //定义char变量,并初始化
        char c = 'A';
        //调用isChar方法,把结果保存到boolean变量flag中
        boolean flag = isChar(c);
        System.out.println(flag);
    }
    /*
        2.定义方法,判断一个字符是否是字母
     */
    public static boolean isChar(char ch) {
        if((ch>='A'&&ch<='Z')||(ch>='a'&&ch<='z')) {
            return true;
        }
        return false;
    }
}
 /*
        4.定义方法,计算一个int数组的和
     */
    public static int getArraySum(int[] array) {
        int sum = 0;
        for(int i = 0;i<array.length;i++) {
            sum += array[i];
        }
        return sum;
    }
public class Demo05DefineMethod {
    public static void main(String[] args) {
        //定义int数组arr,并初始化
        int[] arr = {10, 20, 30};
        //定义int数组arr2,并初始化
        int[] arr2 = {100, 200, 300};
        //调用isSame方法
        boolean flag = isSame(arr,arr2);
        System.out.println(flag);
    }

    /*
        5.定义方法,计算两个int数组是否相同
     */
    public static boolean isSame(int[] arrayA, int[] arrayB) {
        if(arrayA.length != arrayB.length)  {
            return false;
        }
        for(int i = 0;i<arrayA.length;i++) {
            if(arrayA[i] != arrayB[i]) {
                return false;
            }
        }
        return true;
    }
}
/*
    方法
        1.概念： 就是功能，把一段具有特殊功能的代码，使用{}括起来，起了个名字，添加额外的修饰符，方便调用
        2.格式：
            修饰符 返回值类型 方法名称(参数列表...) {
                方法体;//就是完成特殊功能的一段功能代码;
                return 结果数据;
            }
        3.格式解释:
            (1)修饰符: 目前固定写法public static ,先记住
            (2)返回值类型: 方法内部功能代码执行完毕后,产生的结果数据的具体类型
            (3)方法名称: 就是一个标识符,给方法起个名字,方便调用
            (4)参数列表: 本质就是在定义一个/多个变量,用来接收调用者调用方法时传递的数据
            (5)方法体: 完成特殊功能的一段代码
            (6)return 结果数据:
                a.结束方法
                b.把结果数据返回给方法的调用者
        4.注意:
            方法定义后,不调用不执行
            如果调用,可以调用任意多次
            调用格式:
                数据类型 变量名称 = 方法名称(参数列表...);
        5.定义方法的三要素:
            (1)方法名称: 就是给方法起个名字,方便调用
            (2)是否有未知数据参加运算: 参数列表
            (3)是否产生结果数据: 返回值类型
 */
public class Demo02 {
    //定义main方法
    public static void main(String[] args) {
        int m = 10, n = 20;
        int sum =  getSum(m, n);
        System.out.println("和: " + sum);

        int i = 100, j = 200;
        int sum2 = getSum(i, j);
        System.out.println("和： " + sum2);
    }

    /*
        定义方法，计算两个int数据之和
            1.方法的名字： getSum
            2.参数列表：
                int a, int b: 使用该方法时，需要传递两个int数据
            3.返回值类型： int
     */
    /*
        你必须通过getSum这个名字来调用我这个功能
        你调用我这个功能必须给我传递两个int数据
        我的功能代码执行完毕后,必须给你返回一个int数据
     */
    public static int getSum(int a, int b) {
        int result = a + b;
        return result;//结束方法，把结果数据result返回给调用处、者
    }
}
/*
    需求:
        1.定义方法,计算两个double数据的最小值
    三要素:
        (1)方法名称:                    getMin
        (2)是否有未知数据参加运算:       double a, double b
        (3)是否产生结果数据:            double
            数据类型 变量名称 = 方法名称(参数列表...);
 */
public class Demo01DefineMethod {
    public static void main(String[] args) {
        //调用方法,传递变量
        double i = 1.0, j = 2.0;
        double result = getMin(i, j);
        System.out.println("最小值: " + result);
        //调用方法,传递常量
        double result2 = getMin(8.8, 6.6);
        System.out.println("最小值: " + result2);
    }

    /*
        1.定义方法,计算两个double数据的最小值
     */
    public static double getMin(double a, double b) {
        //使用三元运算符
        double min = (a < b) ? a : b;
        return min;//结束方法,把结果数据min返回给方法的调用处
    }
}
/*
    需求:
        2.定义方法,判断一个字符是否是字母
    三要素:
        (1)方法名称:                isZiMu
        (2)是否有未知数据参加运算:   char ch
        (3)是否产生结果数据:         boolean

 */
public class Demo02DefineMethod {
    public static void main(String[] args) {
        //调用方法,传递变量
        char c = 'd';
        boolean flag = isZiMu(c);
        System.out.println("是否是字母: " + flag);

        //调用方法,传递常量
        //直接输出结果
        System.out.println("e是否是字母: " + isZiMu('e'));
    }

    /*
        2.定义方法,判断一个字符是否是字母
     */
    public static boolean isZiMu(char ch) {
        //字母包含: 小写字母/大写字母
        if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {
            return true;
        }
        //代码执行到这里,说明不是字母
        return false;//结束方法,把结果数据false返回给方法的调用处
    }
}
/*
    需求:
        3.定义方法,判断一个int数字是否是偶数
    三要素:
        (1)方法名称:                isOu
        (2)是否有未知数据参加运算:   int num
        (3)是否产生结果数据:         boolean

 */
public class Demo03DefineMethod {
    public static void main(String[] args) {
        //调用方法,传递变量
        int a = 10;
        boolean result = isOu(a);
        System.out.println(a + "是否是偶数? " + result);
        //调用方法,传递常量
        System.out.println("11是否是偶数? " + isOu(11));
    }

    /*
        3.定义方法,判断一个int数字是否是偶数
     */
    public static boolean isOu(int num) {
        /*if (num % 2 == 0) {
            return true;
        } else {
            return false;
        }*/
        if (num % 2 == 0) {
            return true;
        }
        //代码执行到这里说明是奇数
        return false;//结束方法,把结果数据false返回给方法的调用处
    }
}
  需求:
        4.定义方法,计算一个int数组的和
    三要素:
        (1)方法名称:                    getArraySum
        (2)是否有未知数据参加运算:      int[] array
        (3)是否产生结果数据:            int
 */

public class Demo04DefineMethod {
    public static void main(String[] args) {
        //定义int数组arr,并初始化

        int[] arr = new int[]{100, 200, 300};

        //调用方法,传递数组arr,获取结果保存int变量result中
        int result = getArraySum(arr);
        System.out.println("数组元素之和: " + result);
    }

    /*
        4.定义方法,计算一个int数组的和
     */
    public static int getArraySum(int[] array) {
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum = sum + array[i];
        }

        return sum;//结束方法,把结果数据sum返回给方法的调用处
    }
}
  需求:
        5.定义方法,计算两个int数组是否相同
    三要素:
        (1)方法名称:                    isSameArray
        (2)是否有未知数据参加运算:       int[] arrayA, int[] arrayB
        (3)是否产生结果数据:            boolean

    数组相同的含义?
        任意相同索引下的两个元素值相同
        只要有一个索引下的两个元素不同,则认为这两个数组是不同的
 */

public class Demo05DefineMethod {
    public static void main(String[] args) {
        //定义两个int数组
        int[] arrA = new int[]{10, 20, 30};
        //int[] arrA = null;
        int[] arrB = new int[]{10, 20, 30};
        //int[] arrB = null;
        //调用方法,传递两个int数组,获取boolean结果
        boolean result = isSameArray(arrA, arrB);
        System.out.println("两个数组是否相同? " + result);
    }

    /*
        5.定义方法,计算两个int数组是否相同
     */
    public static boolean isSameArray(int[] arrayA, int[] arrayB) {
        //如果两个null,直接返回true
        //如果arrayA和arrayB保存的地址值是相同的,说明传递过来的是同一个数组,直接返回true
        if (arrayA == arrayB) {
            return true;
        }
        //非空判断,只要有一个是null,直接返回false
        if (arrayA == null || arrayB == null) {
            return false;
        }
        //代码执行到这里,说明传递的数组一定不是null
        //获取数组的长度
        int len = arrayA.length;
        //长度不相同,内容一定不相同
        if (len != arrayB.length) {
            return false;
        }
        //长度相同,遍历数组
        for (int i = 0; i < len; i++) {
            //只要有一个索引下的两个元素不同,则认为这两个数组是不同的
            if (arrayA[i] != arrayB[i]) {
                return false;
            }
        }
        //代码执行到这里,说明两个数组是相同的
        return true;//结束方法,把结果数据true返回给方法的调用处
    }
}
  需求:
        5.定义方法,计算两个int数组是否相同
    三要素:
        (1)方法名称:                    isSameArray
        (2)是否有未知数据参加运算:       int[] arrayA, int[] arrayB
        (3)是否产生结果数据:            boolean

    数组相同的含义?
        任意相同索引下的两个元素值相同
        只要有一个索引下的两个元素不同,则认为这两个数组是不同的
 */

public class Demo06DefineMethod {
    public static void main(String[] args) {
        //定义两个int数组
        int[] arrA = new int[]{10, 200, 30};
        //int[] arrA = null;
        int[] arrB = new int[]{10, 20, 300};
        //int[] arrB = null;
        //调用方法,传递两个int数组,获取boolean结果
        boolean result = isSameArray(arrA, arrB);
        System.out.println("两个数组是否相同? " + result);
    }

    /*
        5.定义方法,计算两个int数组是否相同
     */
    public static boolean isSameArray(int[] arrayA, int[] arrayB) {
        //长度不相同,内容一定不相同
        if (arrayA.length != arrayB.length) {
            return false;
        }
        //长度相同,遍历数组
        for (int i = 0; i < arrayA.length; i++) {
            //只要有一个索引下的两个元素不同,则认为这两个数组是不同的
            if (arrayA[i] != arrayB[i]) {
                return false;
            }
        }
        //代码执行到这里,说明两个数组是相同的
        return true;//结束方法,把结果数据true返回给方法的调用处
    }
}
/*
    定义方法计算两个int数据的最大值
        三要素:
            (1)方法名称:                getMax
            (2)是否有未知数据参加运算:  int a, int b
            (3)是否产生结果数据:        int
 */
public class Demo03MethodMax {
    public static void main(String[] args) {
        System.out.println("main...start...");
        //定义两个int变量m,n并初始化
        int m = 50, n = 100;
        //调用方法获取最大值,保存int变量result中
        int result = getMax(m, n);
        System.out.println("数字: " + m + "和" + n + "的最大值: " + result);
        System.out.println("main...end...");
    }

    /*
        定义方法计算两个int数据的最大值
        三要素:
            (1)方法名称:                getMax
            (2)是否有未知数据参加运算:  int a, int b
            (3)是否产生结果数据:        int
     */
    public static int getMax(int a, int b) {
        //使用三元运算符计算a和b的最大值
        int max = (a > b) ? a : b;
        return max;//结束方法,把结果数据max返回给方法的调用处/者
    }
}
/*
    计算一个int数据是否是偶数
 */
public class Demo04MethodOu {
    public static void main(String[] args) {
        System.out.println("main...start...");
        //定义int变量a,初始值10
        int a = 10;
        //调用方法传递int变量a,获取boolean结果保存boolean变量flag中
        boolean flag = isOu(a);
        System.out.println(a + "是偶数吗? " + flag);

        //调用方法传递常量,获取boolean结果保存boolean变量flag2中
        boolean flag2 = isOu(11);
        System.out.println("11是偶数吗? " + flag2);
        System.out.println("main...end...");
    }

    /*
        计算一个int数据是否是偶数
        三要素:
            (1)方法名称:                isOu
            (2)是否有未知数据参加运算:   int num
            (3)是否产生结果数据:         boolean
     */
    public static boolean isOu(int num) {
        boolean result = (num % 2 == 0) ? true : false;
        return result;//结束方法,把结果数据result返回给方法的调用处/者
    }
}
/*
    需求:
        定义方法,打印从数字1到指定大于1的int数字范围内的所有数字

    三要素:
        (1)方法名称:                    printNumber
        (2)是否有未知数据参加运算:      int maxNum
        (3)是否产生结果数据:            只是输出数字而已,没有具体的运算,也没有产生运算后的结果
                                        没有结果数据,不需要返回结果数据给调用处/者,此处返回值类型必须固定写为void

    注意:
        1.分析需求时,发现方法内部没有产生具体的结果数据,返回值类型必须写成void
        2.方法内部可以写return ; 但是建议省略,绝对不能写 return 数据;
        3.规律: 分析需求时,发现有打印/输出/遍历二字时,该方法一般不需要有返回值,返回值类型固定写为void

        没有返回值的方法的调用:
            方法名称(参数列表...);
 */
public class Demo05PrintNum {
    public static void main(String[] args) {
        int a = 5;
        //调用方法传递变量
        printNumber(a);
        System.out.println("-----------");
        //调用方法传递常量
        printNumber(3);
    }

    /*
        定义方法,打印从数字1到指定大于1的int数字范围内的所有数字
        三要素:
        (1)方法名称:                    printNumber
        (2)是否有未知数据参加运算:      int maxNum
        (3)是否产生结果数据:            只是输出数字而已,没有具体的运算,也没有产生运算后的结果
                                        没有结果数据,不需要返回结果数据给调用处/者,此处返回值类型必须固定写为void
     */
    public static void printNumber(int maxNum) {//void: 表示空的意思
        for (int i = 1; i <= maxNum; i++) {
            System.out.println(i);
        }
        //return ;//结束方法,返回调用处(但是没有带回任何结果数据),建议省略
    }
}
/*
    需求:
        定义方法,将一个int数字指定给(赋值给)一个int数组的每个元素

    三要素:
        (1)方法名称:                fillArray
        (2)是否有未知数据参加运算:  int value,int[] array
            int value: 给数组的每个元素赋的值
            int[] array: 接收被赋值的数组
        (3)是否产生结果数据:
                因为调用方法时,传递的是数组的内存地址,通过该地址找到数组后,给每个元素赋值
                赋值完毕后就可以了,不需要返回数组,因为数组是人家传递给我们的,人家是知道该数组的地址的,
                不需要再返回      返回值类型必须写为void

    注意:
        1.分析需求时,发现方法内部没有产生具体的结果数据,返回值类型必须写成void
        2.方法内部可以写return ; 但是建议省略,绝对不能写 return 数据;
        3.规律: 分析需求时,发现有打印/输出/遍历二字时,该方法一般不需要有返回值,返回值类型固定写为void
        4.数组变量保存的是数组容器在堆内存中的地址值,所以作为方法参数传递的是内存地址值
 */
public class Demo06FillArray {
    public static void main(String[] args) {
        int num = 10;
        int[] arr = new int[3];
        System.out.println("----数组元素默认值----");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("----调用方法把每个元素赋值后----");
        fillArray(num,arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

    /*
        定义方法,将一个int数字指定给一个int数组的每个元素
        三要素:
        (1)方法名称:
        (2)是否有未知数据参加运算:
        (3)是否产生结果数据:
     */
    public static void fillArray(int value, int[] array) {
        //遍历数组
        for (int i = 0; i < array.length; i++) {
            //把每个元素赋值为value
            array[i] = value;
        }
        return;//结束方法,返回调用处
    }
}
/*
    需求:
        定义方法,介绍黑马程序员昌平校区的地址
        "北京市昌平区西三旗产业园金燕龙教学楼"

    三要素:
        (1)方法名称:                printAddress
        (2)是否有未知数据参加运算:   没有,不需要定义参数列表,但是必须保留()
        (3)是否产生结果数据:         没有,返回值类型必须写为void

    注意:
        1.分析需求时,发现方法内部没有产生具体的结果数据,返回值类型必须写成void
        2.方法内部可以写return ; 但是建议省略,绝对不能写 return 数据;
        3.规律: 分析需求时,发现有打印/输出/遍历二字时,该方法一般不需要有返回值,返回值类型固定写为void

    没有返回值没有参数的方法调用
        方法名称();
 */
public class Demo07PrintInfo {
    public static void main(String[] args) {
        System.out.println("main...start...");
        //调用方法,打印信息
        printAddress();
        System.out.println("main...end...");
    }

    public static void printAddress() {
        System.out.println("北京市昌平区西三旗产业园金燕龙教学楼");
        return;//结束方法,返回调用处
    }
}
/*
    方法的注意事项:
        1.方法不能嵌套定义,可以嵌套调用
        2.返回值类型，必须要和return语句返回的类型匹配，否则编译失败 。
        3.不能在return 后面写代码，return 意味着方法结束，所有后面的代码永远不会执行，属于无效代码。
        4.void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据
 */
public class Demo04MethodNotice {
    public static void main(String[] args) {
        //调用方法获取int数字
        int number = getNum();
        //调用方法传递int数字
        printNum(number);

        //嵌套调用方法
        printNum(getNum());
    }

    //定义方法a
    public static void a() {
        //错误: 方法不能嵌套定义
        /*public static void b() {

        }*/
    }

    //定义方法返回int数字
    public static int getNum() {
        return 10;
    }

    //定义方法打印int变量
    public static void printNum(int num) {
        System.out.println(num);
    }
}
import java.util.Scanner;

/*
   方法的注意事项:
        1.方法不能嵌套定义
        2.返回值类型，必须要和return语句返回的类型匹配，否则编译失败 。
        3.不能在return 后面写代码，return 意味着方法结束，所有后面的代码永远不会执行，属于无效代码。
        4.void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据的书写return，后面不加数据

    注意:
        1.方法的参数可以有(1个/2个/3个/...),可以没有(0个),可以是基本类型,也可是引用类型,具体情况根据需求分析
        2.方法的返回值类型可以有,也可以没有,可以是基本类型,也可以是引用类型,具体情况根据需求分析
            方法如果有返回值的话,返回值必须只能有一个
 */
public class Demo05MethodNotice {
    public static void main(String[] args) {

    }
    //2.返回值类型，必须要和return语句返回的类型匹配，否则编译失败
    public static int getNum() {
        return 10;//正确: 数字10默认就是int类型
        //return 10L;//正确: 数字10L是long类型数字,不能直接当成int用
        //return 'a';//正确: 字符'a'可以当成int使用,查ASCII码表
        //return (byte)100;//正确: byte数据可以当成int使用,发生自动类型转换
        //return 6.6;//错误: 小数6.6默认是double类型,不能直接当成int用
    }

    public static int getMax(int a, int b) {
        if (a > b) {
            return a;
            //错误: 属于无效代码,永远不可能被执行
            //System.out.println("-----------");
        } else {
            return b;
            //错误: 属于无效代码,永远不可能被执行
            //System.out.println("-----------");
        }
        //错误: 属于无效代码,永远不可能被执行
        //System.out.println("----------");
    }

    //1.方法的参数可以有(1个/2个/3个/...),可以没有(0个),可以是基本类型,也可是引用类型,具体情况根据需求分析
    public static void a(){}
    public static void a2(int a){}
    public static void a3(int[] a){}
    public static void a4(int a, int[] b, Scanner sc){}

    //2.方法的返回值类型可以有,也可以没有,可以是基本类型,也可以是引用类型,具体情况根据需求分析
    //方法如果有返回值的话,返回值必须只能有一个
    public static void b(){}
    public static int b2(){return 0;}
    public static Scanner b3(){return null;}
    public static int[]  b4() {
        int[] arr = new int[] {10,20,30};
        return arr;
    }
}
/*
    有返回值的方法的调用
        1.赋值调用: 把调用有返回值方法的返回的结果赋值给左侧的变量         ---推荐使用---
            数据类型 变量名称 = 方法名称(参数列表....)

        2.打印/输出调用: 把调用有返回值方法的返回的结果直接交给输出语句
            System.out.println(方法名称(参数列表....));

        3.单独/独立/直接调用: 直接调用有返回值方法,对结果数据没有任何处理(丢失了结果)       ---不推荐使用---
            方法名称(参数列表....);
 */
public class Demo06MethodInvoke {
    public static void main(String[] args) {
        int m = 10, n = 20;
        //1.赋值调用方法,传递变量
        int result = getSum(m, n);
        System.out.println("和: " + result);
        //2.赋值调用方法,传递常量
        int result2 = getSum(10, 20);
        System.out.println("和: " + result2);

        //3.输出调用方法,传递变量
        System.out.println("和: " + getSum(m, n));
        //4.输出调用方法,传递常量
        System.out.println("和: " + getSum(10, 20));

        int i = 1000,j = 2000;
        //5.单独调用方法,传递变量
        getSum(i,j);
        //6.单独调用方法,传递常量
        getSum(1000, 2000);
    }

    //定义方法,计算2个int数据的和
    public static int getSum(int a, int b) {//形式参数
        int sum = a + b;
        return sum;
    }
}
/*
    无返回值的方法调用方式
       1.单独/独立/直接调用: 直接调用有返回值方法,对结果数据没有任何处理   ---只能使用这种方式---
           方法名称(参数列表....);

       2.赋值调用: 把调用有返回值方法的返回的结果赋值给左侧的变量         ---代码语法格式错误---

       3.打印/输出调用: 把调用有返回值方法的返回的结果直接交给输出语句     ---代码语法格式错误---
 */
public class Demo07MethodInvoke {
    public static void main(String[] args) {
        int i = 1000,j = 2000;
        //5.单独调用方法,传递变量
        getSum(i,j);//实际参数: 是在调用方法时()中指定的变量,此时该变量必须有值,否则报错
        //6.单独调用方法,传递常量
        getSum(1000, 2000);//实际参数: 是在调用方法时()中指定的常量
    }

    //定义方法,打印2个int数据的和
    public static void getSum(int a, int b) {//形式参数: 是在定义方法时,()中定义的变量,此时没有值,也不能给值
        int sum = a + b;
        System.out.println(sum);
        return;
    }
}
/*
    循环嵌套
        1.概念: 使用一个循环作为另外一个循环的循环体
            里面的循环叫做内层循环,外面的循环叫做外层循环
        2.格式:
            for(外初始化表达式1;外循环条件2;外步进表达式7){

                for(内初始化表达式3;内循环条件4;内步进表达式6){

                    内循环体5;

                }

            }
        3.注意:
            (1)外层循环初始化表达式执行几次?   1次
            (2)内层循环初始化表达式执行几次?   3次
            (3)内层循环体代码执行几次?
                   外层循环次数 * 内层循环每遍执行的次数 = 3*5 = 15
            (4)外层循环执行一次,内层循环执行完整的一遍
 */
public class Demo05ForFor {
    public static void main(String[] args) {
        /*
            输出3行5列的星
         */
        System.out.println("*****");
        System.out.println("*****");
        System.out.println("*****");
        System.out.println("----------------");
        //问题: 代码重复,如果输出行数比较多的话,数不过来了吧
        for (int i = 1; i <= 3; i++) {
            System.out.println("*****");
        }
        System.out.println("----------------");
        //问题: 如果每行的星的数量非常多的话,数不过来了吧
        for (int i = 1; i <= 3; i++) {//外层循环: 控制行数
            for (int j = 1; j <= 5; j++) {//内层循环: 控制列数
                System.out.print("*");
            }
            System.out.println();//换行
        }
    }
}
/*
    输出2021年到2023年的所有的月份
 */
public class Demo06ForForMonth {
    public static void main(String[] args) {
        //外层循环: 控制年份
        for (int year = 2021; year <= 2023; year++) {
            //内层循环: 控制每年的月份,每一年都有12个月
            for (int month = 1; month <= 12; month++) {
                System.out.println(year + "年" + month + "月");
            }
        }
        System.out.println("game...over...");
    }
}
/*
    输出九九乘法表
 */
public class Demo07CFB {
    public static void main(String[] args) {
        /*
            输出9行9列的*
            *********
            *********
            *********
            *********
            *********
            *********
            *********
            *********
            *********
         */
        for (int i = 1; i <= 9; i++) {//外层循环: 控制行数
            for (int j = 1; j <= 9; j++) {//内层循环: 控制每行输出的列数
                System.out.print("*");
            }
            System.out.println();
        }
        System.out.println("-------------------------------------------");
        /*
            如果能打印出下面的直角三角形来的话,只需要把*号替换成对应的表达式
            *
            **
            ***
            ****
            *****
            ******
            *******
            ********
            *********
         */
        for (int i = 1; i <= 9; i++) {//外层循环: 控制行数
            for (int j = 1; j <= i; j++) {//内层循环: 控制每行输出的列数
                System.out.print("*");
            }
            System.out.println();
        }
        System.out.println("-------------------------------------------");
        /*
            把上面的*号替换成对应的表达式
            \t: 就是键盘上的tab键,叫做制表符,大的空格
         */
        for (int i = 1; i <= 9; i++) {//外层循环: 控制行数
            for (int j = 1; j <= i; j++) {//内层循环: 控制每行输出的列数
                System.out.print(j + "×" + i + "=" + j * i + "\t");
            }
            System.out.println();
        }
    }
}

Codefacebook
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
fivemethod文档
2406_85562971的博客
07-28 550
/定义2个int变量a和b,并初始化//调用方法完成求和//打印结果​//定义方法完成计算两个int数据之和根据以上关于方法的说明,完成方法的定义,不需要完成方法内部的功能代码1.定义方法,计算两个double数据的最小值2.定义方法,判断一个字符是否是字母3.定义方法,判断一个int数字是否是偶数4.定义方法,计算一个int数组的和5.定义方法,计算两个int数组是否相同修饰符 返回值类型 方法名(参数列表){//代码省略...return 结果;
抽象类、接口、抽象类和接口的比较
qq_18364087的博客
07-27 149
目录 抽象类 抽象类 vS 普通类 的成员特点: 练习 接口 接口的语法 接口的特点 抽象类和接口的比较 练习 抽象类 包含 有抽象方法的类 或 被abstract修饰的类 引入抽象类会有一个强制约束力，子类方法必须覆盖 抽象类和抽象方法必须用abstract关键字修饰 abstract class 类名{ } //不能 new 类名 public abstract void eat(); //没有方法体 抽象类不一定有抽象方法，有抽象方法的类一定是抽...
Java基础： 反射常见知识整理
微不足道的博客
08-27 1364
反射是一种功能强大且复杂的机制 。 使用它的主要人员是工具构造者， 而不是应用程序员。 在实际开发中，我们更多的是在阅读系统或第三方源码看到他们的身影。 本文，将对反射中常见的知识进行总结学习。
JAVA写的计算器
libingbojava的博客
09-15 499
第一次写(JAVA的计算器，新手勿喷）。  哈哈啊哈哈
iOS 线程锁的概念以及使用
yaoqi447103345的专栏
05-04 696
1.概念： 锁的概念： 锁是最常用的同步工具。一段代码段在同一个时间只能允许被一个线程访问，比如一个线程A进入加锁代码之后由于已经加锁，另一个线程B就无法访问，只有等待前一个线程A执行完加锁代码后解锁，B线程才能访问加锁代码。不要将过多的其他操作代码放到里面，否则一个线程执行的时候另一个线程就一直在等待，就无法发挥多线程的作用了。 使用场景：多线程操作同一个对象的时候就需要加锁。和同步异步没
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 630
1.导入hutool的maven依赖。2.复制一下代码执行。
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
最新发布
m0_74283290的博客
08-03 671
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
社区养老服务小程序的设计
Karen198的博客
07-31 558
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 496
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
JavaSE面向对象进阶
qq_45348840的博客
07-30 503
需求：在实际开发中，经常会遇到一些数组使用的工具类;请按照如下要求编写一个数组的工具类：ArrayUtil提供一个工具类方法printArr,用于返回整数数组的内容。返回的字符串格式如：[10,20,50,34,100 ]（只考虑整数数组，且只考虑一维数组)提供这样一个工具方法getAerage,用于返回平均分。（只考虑浮点型数组，且只考虑一维数组)定义一个测试类TestDemo,调用该工具类的工具方法，并返回结果。// 私有化构造方法// 定义静态方法，方便调用。i++) {
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 384
1.导入hutool的maven依赖。2.直接复制一下代码运行。
花几千上万学习Java，真没必要！（三十五）
wehpd的博客
07-30 671
集合之Map
26.jdk源码阅读之ConcurrentLinkedQueue
前端、移动端、后端源码级底层原理分享
07-29 993
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。
Java并发（十一）一文搞懂Java并发各种容器
m0_58466443的博客
07-29 856
同步容器将所有对容器状态的访问都串行化，以保证线程安全性，这种策略会严重降低并发性。Java 1.5 后提供了多种并发容器，使用并发容器来替代同步容器，可以极大地提高伸缩性并降低风险。并发容器对应的普通容器描述HashMapJava 1.8 之前采用分段锁机制细化锁粒度，降低阻塞，从而提高并发性；Java 1.8 之后基于 CAS 实现。SortedMap基于跳表实现的ArrayListSet基于实现。SortedSet基于实现。Queue线程安全的无界队列。底层采用单链表。支持 FIFO。
javaweb_03：在ide中配置tomcat
qq_52200849的博客
08-01 175
④创建artifact。②点击加号创建，选择。
Spring-包扫描
Promise_J_Z
08-03 162
二次判断类是否可独立实例化对象，内部类或者接口，抽象类都会对应生成一个.class文件，但是这些文件部分是不能够实例化的，不可以生成bean，所以在生成BeanDefinition之前需要进行过滤判断。对扫描到的BeanDefinition进行赋值，但是此时只是将className赋值到BeanDefinition中，因为还没有创建该类。spring在启动的时候就会往includeFilters中加入component注解。判断当前类是否需要当作bean进行处理。
安装ElasticSearch
diffiii
07-31 622
(1).使用WinSCP工具拷贝下载好的安装文件jdk-8u121-linux-x64.gz到建的es文件夹下。(5).修改配置文件elasticsearch-5.2.0/Configs/elasticsearch.yml。plugins—这里存放一些常用的插件，如果有一切额外的插件，可以放在这里使用。(2).切换到elasticsearch根目录，启动elasticsearch。data—这里是ES得当前节点的分片的数据，可以直接拷贝到其他的节点进行使用。1.1.1.6 维护elastic。
【SpringBoot】 定时任务之任务执行和调度及使用指南
ToBeMaybe_的博客
08-03 660
本文将着重介绍Spring中的TaskExecutor接口、TaskScheduler接口、Trigger接口以及Spring中定时任务的任务执行和调度以及开发中的正确使用姿势。
java中static关键字的作用
weixin_41020960的博客
08-01 612
这意味着这个变量被类的所有实例共享，而不是每个实例拥有自己的副本。类变量可以通过类名直接访问，而不需要创建类的实例。关键字是 Java 中一个非常重要的特性，它允许开发者在不创建对象的情况下访问类的方法和变量，这在很多场景下非常有用。这类方法可以在没有创建类的实例的情况下被调用，它们只能访问类的静态变量和静态方法。关键字也可以用于静态初始化块，这是一段在类加载时执行的代码块，用于初始化静态变量。: 静态变量是不变的，一旦在静态初始化块或静态方法中被初始化，它们的值就不能被修改。关键字可以声明静态内部类。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值