Java-day-07

最新推荐文章于 2024-09-15 09:47:04 发布

游荡在雾中的霾

最新推荐文章于 2024-09-15 09:47:04 发布

阅读量75

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/Dreamafterdream/article/details/118089899

版权

Java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

package com.yonyou;

import java.util.Scanner;

@SuppressWarnings("all")
/**
 * 在EditPlus当中，字体颜色为红色的表示一个类的名字，丙炔这个类是JavaSE类库中自带的
 * 我们自定义的类MEthodTest01，字体他白色是黑色，是标识符
 * 其实JavaSE类库中自带的类，例如，String.class、System.class，这些类的类名也是标识符
 * 只要是类名就一定是标识符
 * 重点：方法调用的时候，在参数传递的时候，实际上传递的是变量中保存的哪个“值”传递过去了
 */
public class MethodTest01 {
    public static void main(String[] args) {
        System.out.println("------------------------------------------");
        System.out.println("请输入键盘值：");
        Scanner scanner = new Scanner(System.in);
        System.out.println("获取参数起始值：");
        int start = scanner.nextInt();
        System.out.println("获取参数结束值：");
        int end = scanner.nextInt();
        System.out.println("------------------------------------------");
        int retValue = sumInt(start, end);
        System.out.println("retValue = " + retValue);
        System.out.println("------------------------------------------");
    }

    public static int sumInt(int i, int j) {
        int result = i + j;
        int num = 3;
        int retValue = divide(result, num);
        return retValue;
    }

    public static int divide(int x, int y) {
        int z = x / y;
        return z;
    }
}

package com.yonyou;

import java.util.Scanner;

@SuppressWarnings("all")
/**
 * 分析程序的输出结果
 */
public class MethodTest02 {
    public static void main(String[] args) {
        System.out.println("------------------------------------------");
        Scanner scanner = new Scanner(System.in);
        System.out.println("获取参数起始值：");
        int start = scanner.nextInt();
        System.out.println("获取参数结束值：");
        int end = scanner.nextInt();
        System.out.println("------------------------------------------");
        method(start);
        System.out.println("main ---> " + start);
        System.out.println("------------------------------------------");
    }

    /**
     * void
     *
     * @param i
     */
    public static void method(int i) {
        i++;
        System.out.println("method ---> " + i);
    }
}

package com.yonyou;

import java.util.Scanner;

/**
 * 代码不使用“方法重载机制”，不适用overload
 * 1、sumInt、sumLong、sumDouble方法虽然功能不同名单时功能是相似的，都是求和。
 * 在以下程序打当中功能相似的方法，分别起了三个不同的名字，这对于程序来说，调用方法的时候不方便，程序需要记忆更多的方法，才能完成调用。
 * 2、代码不美观
 * 更加进阶的机制：
 * 功能虽然不同，但是功能相似的时候，有没有这样的一种机制。可以让程序使用这些方法的时候就想在使用同一个方法一样，这样程序以后编写代码比较方便，也不需要记忆更多的方法名，代码也会很美观
 * 方法机制重置：/Overload
 */
@SuppressWarnings("all")
public class OverloadTest01 {
    /**
     * main入口
     *
     * @param args
     */
    public static void main(String[] args) {
        System.out.println("------------------------------------------");
        Scanner scanner = new Scanner(System.in);
        System.out.println("获取参数起始值：");
        int start = scanner.nextInt();
        System.out.println("获取参数结束值：");
        int end = scanner.nextInt();
        System.out.println("------------------------------------------");
        /**
         * 调用方法
         */
        int sumint = sumInt(start, end);
        System.out.println(sumint);
        long sumlong = sumLong(1L, 2L);
        System.out.println(sumlong);
        double sumdouble = sumDouble(1.0, 2.0);
        System.out.println(sumdouble);
        System.out.println("------------------------------------------");
    }

    /**
     * 定义一个方法，可以计算 两个int类型数据额和
     */
    public static int sumInt(int a, int b) {
        return a + b;
    }

    /**
     * 定义一个方法，可以计算 两个double类型数据额和
     */
    public static double sumDouble(double a, double b) {
        return a + b;
    }

    /**
     * 定义一个方法，可以计算 两个long类型数据额和
     */
    public static long sumLong(long a, long b) {
        return a + b;
    }
    /**
     * 最终目标为：程序员在使用上面三个相似的方法的时候，就像在使用同一个方法的情况
     * 重点是相似的方法，即都是相同参数的加法，而不是加法与减法
     */
}

package com.yonyou;

import java.util.Scanner;

/**
 * 着重点：方法重载
 */
@SuppressWarnings("all")
public class OverloadTest02 {
    public static void main(String[] args) {
        System.out.println("------------------------------------------");
        Scanner scanner = new Scanner(System.in);
        System.out.println("获取参数起始值：");
        int start = scanner.nextInt();
        System.out.println("获取参数结束值：");
        int end = scanner.nextInt();
        System.out.println("------------------------------------------");
        /**
         * 调用方法的时候就像在使用同一个方法一样
         */
        System.out.println(sum(start, end));
        System.out.println(sum(1.0, 2.0));
        System.out.println(sum(1L, 2L));
        System.out.println("------------------------------------------");
    }

    /**
     * 定义一个方法，可以计算 两个int类型数据额和
     */
    public static int sum(int a, int b) {
        return a + b;
    }

    /**
     * 定义一个方法，可以计算 两个double类型数据额和
     */
    public static double sum(double a, double b) {
        return a + b;
    }

    /**
     * 定义一个方法，可以计算 两个long类型数据额和
     */
    public static long sum(long a, long b) {
        return a + b;
    }
}

package com.yonyou;

import java.util.Scanner;


@SuppressWarnings("all")
/**
 * 方法重载：
 *      1、方法重载又被称为：overload
 *      2、什么时候考虑使用方法重载？
 *          * 功能相似的时候，尽可能让方法名不同
 *          【但是：功能不同/不相似的时候，尽可能让方法名不同】
 *      3、什么条件满足之后构成了方法重载？
 *          * 在同一个类当中
 *          * 方法名相同
 *          * 参数列表不同：
 *              - 数量不同
 *              - 顺序不同
 *              - 类型不同
 *      4、方法重载和什么有关系，和什么没有关系？
 *          * 方法重载和方法名+参数列表有关系
 *          * 方法重载和返回值类型无关
 *          * 方法重载和修饰符列表无关
 *
 */
public class OverloadTest03 {
    public static void main(String[] args) {
        System.out.println("------------------------------------------");
        Scanner scanner = new Scanner(System.in);
        System.out.println("获取参数起始值：");
        int start = scanner.nextInt();
        System.out.println("获取参数结束值：");
        int end = scanner.nextInt();
        System.out.println("------------------------------------------");
        m1();
        m1(start);
        m2(1, 2.0);
        m2(1.0, 2);
        m3(1);
        m3(2.0);
        System.out.println("------------------------------------------");
    }

    /**
     * 构成重载
     */
    public static void m1() {
    }


    public static void m1(int a) {
    }


    /**
     * @param a
     * @param b
     */
    public static void m2(int a, double b) {
    }


    public static void m2(double a, int b) {
    }

    /**
     * 构成重载
     *
     * @param x
     */
    public static void m3(int x) {
    }

    public static void m3(double x) {
    }

}

package com.yonyou;

import java.util.Scanner;

@SuppressWarnings("all")
/**
 * 方法重载的具体应用
 */
public class OverloadTest04 {
    public static void main(String[] args) {
        System.out.println("------------------------------------------");
        Scanner scanner = new Scanner(System.in);
        System.out.println("获取参数起始值：");
        int start = scanner.nextInt();
        System.out.println("获取参数结束值：");
        int end = scanner.nextInt();
        System.out.println("------------------------------------------");
        System.out.println("今天也是充满希望的一天");
        U.p(10);
        U.p(false);
        U.p("abc");
        U.p(3.0);
        System.out.println("------------------------------------------");
    }
}

/**
 * 自定义类
 */
class U {
    public static void p(byte b) {
        System.out.println(b);
    }

    public static void p(int b) {
        System.out.println(b);
    }

    public static void p(short b) {
        System.out.println(b);
    }

    public static void p(long b) {
        System.out.println(b);
    }

    public static void p(double b) {
        System.out.println(b);
    }

    public static void p(float b) {
        System.out.println(b);
    }

    public static void p(char b) {
        System.out.println(b);
    }

    public static void p(boolean b) {
        System.out.println(b);
    }

    public static void p(String b) {
        System.out.println(b);
    }

}

package com.yonyou;

import java.util.Scanner;
@SuppressWarnings("all")
/**
 *
 */
public class OverloadTest05 {
    public static void main(String[] args) {
        System.out.println("------------------------------------------");
        Scanner scanner = new Scanner(System.in);
        System.out.println("获取参数起始值：");
        int start = scanner.nextInt();
        System.out.println("获取参数结束值：");
        int end = scanner.nextInt();
        System.out.println("------------------------------------------");
        System.out.println("今天也是充满希望的一天");
        U.p("hhhhhh");
        System.out.println("------------------------------------------");
    }
}

package com.yonyou;

import java.util.Scanner;

@SuppressWarnings("all")
/**
 *关于方法的递归调用
 *      1、什么是递归
 *          方法自身调用自身
 *          a(){
 *              a();
 *          }
 *       2、递归是很耗费栈内存的，递归算法可以不用尽量不使用
 *       3、错误程序：不是异常，是错误
 *          java.lang.StackOverError
 *          栈内存溢出错误
 *          错误发生无法挽回，只有一个结果，就是JVM停止工作。
 *       4、递归必须有结束条件，没有结束条件一定会发生栈内存溢出错误。
 *       5、递归即使有了结束条件，即使结束条件是正确的，也可能会发生栈内存溢出错误，应为递归的太深了
 *       注意点：
 *          递归可以不使用尽量别用
 *          但是有些情况下该功能的实现必须依靠递归方式。
 * 不使用递归，计算1~N的和【可以不用递归，尽量不同递归】
 */
public class RecursionTest01 {
    public static void main(String[] args) {
        System.out.println("------------------------------------------");
        Scanner scanner = new Scanner(System.in);
        System.out.println("获取参数起始值：");
        int start = scanner.nextInt();
        System.out.println("获取参数结束值：");
        int end = scanner.nextInt();
        System.out.println("------------------------------------------");
//        /**
//         * 1~4的和
//         */
//        int sum = 0;
//        for (int i = start; i <= end; i++) {
//            sum += i;
//        }
//        System.out.println("sum ---> "+sum);
        /**
         * 直接调用方法即可
         */
        System.out.println(sum(start, end));

        System.out.println("------------------------------------------");
    }

    /**
     * 以下的代码片段虽然只要一份
     * 但是可以被重复的调用，并且只要调用doSome方法就会在栈内存中新分配一块所属的内存空间
     */
//    public static void doSome() {
//        System.out.println("begin");
//        /**
//         * 这行代码不结束，下一行程序是不能执行的
//         */
//        doSome();
//        System.out.println("over");
//    }

    /**
     * 单独定义一个方法：这是一个独立的功能，可以完成1~N的求和
     */
    public static int sum(int n, int m) {
        int result = 0;
        for (int i = n; i <= m; i++) {
            result += i;
        }
        return result;
    }
}

package com.yonyou;

import java.util.Scanner;

@SuppressWarnings("all")
/**
 * 使用递归九三的1~N的求和
 * 使用递归计算1~N的求和
 *      ---> 1 + 2 3 + 4
 *      ---> 4 + 3 2 + 1
 */
public class RecursionTest03 {
    public static void main(String[] args) {
        System.out.println("------------------------------------------");
        Scanner scanner = new Scanner(System.in);
        System.out.println("获取参数起始值：");
        int start = scanner.nextInt();
        System.out.println("获取参数结束值：");
        int end = scanner.nextInt();
        System.out.println("------------------------------------------");
        System.out.println(sum(start, end));
        System.out.println("------------------------------------------");

    }

    /**
     * 求和方法
     *
     * @param a
     * @param b
     * @return
     */
    public static int sum(int a, int b) {
        int result = 0;
        for (int i = a; i <= b; i++) {
            result += i;
        }
        System.out.println(a + "+" + b + "=" + (a + b));
        return result;

    }
}

package com.yonyou;

import java.util.Scanner;

@SuppressWarnings("all")
/**
 * 1、方法：
 *      * 方法执行过程中的内存分配
 *      * 方法的重载机制
 *      * 方法的递归调用
 * 2、总结第二章的内容：
 *      * 标识符
 *      * 关键字
 *      * 字面值
 *      * 变量
 *      * 数据类型
 *      * 二进制
 *      * 字符编码
 *      * 运算符
 *      * 控制语句
 *      * 方法
 *      * 递归
 * 3、第三章：面向对象【Java语言的核心机制，最重要的内容，Java语言的特色】
 *      * 面向过程和面向对象的区别
 *          - 面向过程：主要关注的点是：实现的具体过程，因果关系
 *              * 优点：对于业务逻辑简单的程序，可以达到快速开发，前期投入成本较低
 *              * 缺点：采用面向过程的方式开发很难解决非常复杂的业务逻辑，另外面向过程的方式导致软件元素之间的“耦合度”非常高，
 *              只要其中一环出问题，整个系统受到影响，导致最终的软件扩展力差。另外，由于没有独立体的概念，所以无法达到组件复用。
 *          - 面向对象：主要关注点是：主要关注对象【独立体】能完成那些功能，
 *              * 优点：耦合度低，扩展力强，更容易解决现实世界当中更复杂的业务逻辑。组件复用性强
 *              * 缺点：前期投入成本较高，需要进行独立体的抽取，大量的系统分析与 设计
 *          - C语言是纯面向过程的、C++半面向对象、Java纯面向对象
 *          - 现在出现的一些新的编程语言都是面向对象的，人在认识现实世界的时候以向对象的，人在认识显示世界的时候以面向对象的方式
 *          - 面向对象更符合人的思维方式
 *      * 面向对象的三大特征
 *          - 封装
 *          - 继承
 *          - 多态
 *          所有的面向对象都具有这三大特征
 *
 *          采用面向对象的方式开发一个软件，生命周期当中：【整个生命周期中贯穿使用oo面向对象方式】
 *              * 面向对象的分析：OOA
 *              * 面向对象的设计：OOD
 *              * 面向对象的编程：OOP
 *              Java就是一个纯面向对象
 *      * 类和对象的概念
 *          * 什么是类？
 *              - 类在显示世界当中是不存在的，是一个模板，是一个概念，是人类大难思考抽象的结果。
 *              - 类代表了一类事物
 *              - 在现实世界当中，对象A与对象B之间具有共同特征，进行抽象总结一个模板，这个模板被称为类
 *          * 什么是对象？
 *              - 对象是实际存在的个体。现实世界当中实际存在。
 *
 *          * 描述一下整个软件开发的过程：
 *              * 程序员先观察现实世界，从现实世界当中实际存在
 *          * 描述软件开发：
 *              * 程序员先观察现实世界，从现实世界当中寻找对象
 *              * 寻找N个对象，发现所有的对象都具有共同特征
 *              * 程序员在大脑中形成一个模板【类】‘
 *              * Java程序员可以通过Java代码来表述一个类
 *              * Java程序中有了类的定义
 *              * 然后通过类就可以创建对象
 *              * 有了对象之后，可以让v对象直接协作起来形成一个系统。
 *          * 类--【实例化】-->对象
 *          * 对象又被称为实例
 *          * 对象--【抽象】-->类
 *          * 重点：类描述的是对象的共同特征。
 *                  共同特征例如：身高特征
 *                  这个升高特征在访问的时候，必须先创建对象，通过对象去访问这个特征。
 *                  应为这个特征具体的某个对象上之后，值不同，有点对象身高1.80，有点对象2.80
 *          * 一个类主要描述什么信息？
 *              一个类主要描述的是状态+动作。
 *              状态信息：名字、身高、性别、年龄
 *              动作信息：吃、唱
 *          * 类{
 *              属性；//描述对象的状态信息
 *              方法：//描述对象的动作信息
 *              }
 *            注意：状态和动作当具体到某个对象上之后，发现最终的结果可能不一样。
 *                 对象和对象之间有共同特征，但是具体到对象之后有数据的差异
 *
 *          * 类的定义
 *              语法结构：
 *                  {
 *                      【修饰符列表】 class 类名{
 *
 *                      }
 *                  }
 *              学生类，描述所有学生对象的共同特征：
 *                  学生对象有哪些状态信息：
 *                      * 学号【int】
 *                      * 名字【String】
 *                      * 性别【bolean】
 *                      * 年龄【int】【年龄是一个属性，年龄是一个数据，是数据就应该有数据类型】
 *                      * 住址【String】
 *                  学生对象有哪些动作信息：
 *                      * 吃饭
 *                      * 睡觉
 *                      * 学习
 *                      * 等待...
 *              重点：属性通常是采用一个变量的形式来完成定义的
 *
 *
 */
public class RecursionTest04 {
    public static void main(String[] args) {
        System.out.println("------------------------------------------");
        Scanner scanner = new Scanner(System.in);
        System.out.println("获取参数起始值：");
        int start = scanner.nextInt();
        System.out.println("获取参数结束值：");
        int end = scanner.nextInt();
        System.out.println("------------------------------------------");
        System.out.println(method(start, end));
        System.out.println("------------------------------------------");

    }

    public static int method(int n, int m) {

        for (int i = n; i > 0; i--) {
            m *= i;
        }
        return m;
    }
}