java基础案列与注意

最新推荐文章于 2023-11-29 09:54:57 发布
最新推荐文章于 2023-11-29 09:54:57 发布
阅读量122 收藏 1
点赞数
分类专栏： java学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54425421/article/details/117408803
版权

基础案列与注意

数组静态初始化简化格式

int[] arr = {数据1，数据2...};

遍历数组

//遍历数组

public class Demo {
    public static void main(String[] args) { ;
        int[] arr1 = new int []{1,5,8,4,5,7};
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);
        }
            }
            }

获取最大值

//获取最大值
public class Demo {
    public static void main(String[] args) {
        int[] arr1 = new int[]{6, 3, 2, 4, 5, 1};
        int max = arr1[0];
        for (int i = 1; i < arr1.length; i++) {
            if (arr1[i] > max) {
                max = arr1[i];
            }
        }
        System.out.println(max);
    }
}
  • 不带参数方法的调用 ：方法名（）；
  • void类型带参数方法的调用 ：方法名（实际参数）；
  • 带参数方法的定义

格式：public static void 方法名（参数1，参数2）{…}

  • 带参数方法的调用

格式：方法名（参数1，参数2）；

  • 形参和实参

  • 形参：方法定义中的参数

    实参数：方法调用的参数

  • 带返回值方法的的定义

public static 数据类型 方法名(参数){
    return 数据;
}
  • 带返回值方法的调用
数据类型 变量名 = 方法名(参数)；
  • 方法注意事项
  1. 方法不能嵌套
  2. void表示没有返回值，可以省略return，也可以单独写一个return；
  3. return表示已经方法已经结束。

方法重载

方法重载指同一个类中的多个方法之间的关系，满足以下条件构成方法重载

  1. 多个方法在同一个类中
  2. 多个方法具有相同的方法名
  3. 多个方法具有参数不相同，类型不同或者数量不同
public class Demo {
    public static void main(String[] args) {

        System.out.println(sum(55,98));
        System.out.println(sum(55,98,87));
    }
    public static int  sum(int a,int b){
int sum = a+b;
return  sum;
    }
    public static int sum(int a,int b ,int c){
        int sum = a+b+c;
        return sum;
    }
}
  • 注意

对于基本数据类型的参数，形式参数的改变，不影响实际参数的值

public class Demo {
    public static void main(String[] args) {
   int number = 100;
        System.out.println("调用change前的方法"+number);
        change(number);
        System.out.println("调用change后的方法"+number);
    }
    public static void change(int number){
        number = 200;
    }
}
//第一一次输出：100 第二次输出 100
  • 方法参数传递（引用类型）

对于应用类型的参数，形式参数改变会影响实际参数的值

public class Demo {
    public static void main(String[] args) {
   int number = 100;
        System.out.println("调用change前的方法"+number);
        change(number);
        System.out.println("调用change后的方法"+number);
    }
    public static void change(int number){
        number = 200;
    }
}
/*
调用change方法前30
调用change方法后1000
*/

数组遍历

public class Demo {
    public static void main(String[] args) {
        int[] arr = {10,40,51,15,15,99,88,45,63};
        printArray(arr);
    }
    public static void  printArray(int[] arr){
        System.out.print("[");
        for (int i = 0; i <arr.length ; i++) {
            if(i<arr.length &&i>0) {
                System.out.print(",");
            }
        System.out.print(arr[i]+"\t");
        }
        System.out.print("]");
    }
}
//[10	,40	,51	,15	,15	,99	,88	,45	,63	]

数组最大值

//数组最大值
public class Demo {
    public static void main(String[] args) {
        int[] arr = {10, 40, 51, 15, 15, 99, 88, 45, 63};
      System.out.println(max(arr));
    }

    public static int max(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];


            }
        }
        return max ;
    }
}

输入一个数，判断要做什么

package Demo1;
import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
  while(true){
      System.out.println("===========");
        Scanner sc = new Scanner(System.in);
      System.out.println("输入0结束运行");
      System.out.println("请输入一个星期数");
      int   week = sc.nextInt();
      System.out.println("你输入的是"+":"+week);
        if (week < 0 || week > 7) {
            System.out.println("你所输入有误，请重新输入");
        } else if (week == 1) {
            System.out.println("你要做的是：跑步");
        } else if (week == 2) {
            System.out.println("你要做的是：滑板");
        } else if (week == 3) {
            System.out.println("你要做的是：学习");
        } else if (week == 4) {
            System.out.println("你要做的是：玩游戏");
        } else if (week == 5) {
            System.out.println("你要做的是：骑马");
        } else if (week == 6) {
            System.out.println("你要做的是：看书");
        } else if (week == 7) {
            System.out.println("你要做的是：看电影");
        }else if(week==0) {
            System.out.println("===========");
            System.out.println("已经结束运行");
            break;
        }
        }
    }
}
//输入一个数，判断要做什么

不死兔子

//不死兔子
public class Demo {
    public static void main(String[] args) {
       int[]  arr = new int [20];
       arr[0]=1;
       arr[1]=1;
       /*arr[3]=2;
       arr[4]=3;
       arr[5]=5;
       arr[6]=8；
        */
        for (int i = 2; i < arr.length; i++) {
            arr[i]=arr[i-1]+arr[i-2];
        }
        System.out.println("第20个月的兔子数量是"+arr[19]);
    }
}

百钱百鸡

//白钱白鸡
public class Demo {
    public static void main(String[] args) {
        for (int i = 0; i <=20 ; i++) {
            for (int j = 0; j <=33 ; j++) {
                int z = 100-i-j;
                if (z%3==0 && 5*i+3*j+z/3==100) {
                        System.out.println(i+"\t"+j+"\t"+z);
                }
            }
        }
    }
}

判断数组内容是否相同

package Demo1;
//判断数组内容是否相同
import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3, 4, 5, 6};
        int[] arr2 = {1, 2, 3, 4, 5,6};
        int[] arr3 = {1, 2, 3, 4, 5};
        int[] arr4 = {1, 2, 3, 4, 5,7};

      boolean flag = compare(arr1,arr2);
      boolean flag1 = compare(arr1,arr3);
      boolean flag2 = compare(arr1,arr4);
      boolean flag3 = compare(arr2,arr4);
      boolean flag4 = compare(arr2,arr3);
        System.out.println(flag);
        System.out.println(flag1);
        System.out.println(flag2);
        System.out.println(flag3);
        System.out.println(flag4);

    }

    public static boolean compare(int arr1[], int arr2[]) {
        if (arr1.length != arr2.length) {
            return false;
        }
        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] != arr2[i]) {
                return false;
            }
        }
        return  true;
    }
}

/*true
false
false
false
false
*/

查找数组中元素对应的索引

//查找数组中元素对应的索引
package Demo1;
import java.util.Scanner;
public class Demo {
    public static void main(String[] args) {
        int[] arr = {1, 5, 1, 58, 4, 4, 8, 4, 5, 9, 8, 4, 1, 5, 8, 8, 8, 4, 4, 5};
       int index = check(arr,4);
       /* Scanner sc = new Scanner(System.in);
        System.out.println("输入需要查找的数据" );
        int index =-1;
     int s1 = sc.nextInt();
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]== s1){
                index = i;
                System.out.println("index:"+ index);

        */
            }
            public static int check(int arr[],int a){
    Scanner sc = new Scanner(System.in);
        System.out.println("输入需要查找的数据" );
    int index =-1;
    int s1 = sc.nextInt();
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == s1) {
                index = i;
                System.out.println("index:" + index);
    
            }
    
        }
        return index;
    }
}

数组反转

//数组反转
package Demo1;
import javax.xml.soap.SAAJMetaFactory;
import java.util.Scanner;
public class Demo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        printArray(arr);
        reverse(arr);
        System.out.println();
        printArray(arr);
        }
    public static void printArray(int[] arr){
        System.out.print("[");
        for (int i = 0; i <arr.length ; i++) {
            if (i ==arr.length-1) {
                System.out.print(arr[i]);
            }else {
                System.out.print(arr[i]+",");
            }
        }
        System.out.print("]");
    }
    public static void reverse(int[] arr) {
        for (int start = 0, end = arr.length - 1; start <= end; start++, end--) {
            int temp = arr[start];
            arr[start] = arr[end];
            arr[start] = temp;

        }
    }
}

评委打分

package Demo1;
//评委打分
import javax.xml.soap.SAAJMetaFactory;
import java.util.Scanner;
public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int arr[] = new int[6];
        for (int i = 0; i < arr.length; i++) {
            System.out.println("其输入第个" + (i + 1) + "评委的打分");
            arr[i] = sc.nextInt();
        }
        System.out.println();
        int max = max(arr);
        int min= min(arr);
        int sum = sum(arr);
        int avg = (sum - min -max )/(arr.length-2);
        System.out.println("=================");
        System.out.print("你输入的分数分别是");
        printArray(arr);
        System.out.println();
        System.out.println("最终得分为:"+" "+avg);
    }

    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i]);
            } else {
                System.out.print(arr[i] + ",");
            }
        }
        System.out.print("]");

    }

    public static int max(int arr[]) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[ i] >max) {
                max = arr[i];

           }
        }
        return max;
    }

    public static int min(int arr[]) {
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i ] < min) {
                min = arr[i ];
            }
        }
        return min;
    }
    public static int sum(int arr[]){
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
             sum = arr[i]+sum;
        }
        return  sum;
    }
}
pofenx
关注
专栏目录
JavaSE练习
Demon_and_Angle_的博客
07-26 698
c、声明静态工厂方法getDrink(intdrinkType)根据传入的参数创建不同的饮料对象并返回该对象建议使用switch语句。b、在Drink的方法getDrink(intdrinkType)中声明引发DrinkNotFoundException异常当传入的参数没有相对应的饮料类型时抛出异常。b、在main方法中调用Drink类的getDrink方法获得相应的饮料对象。具有一个抽象的play()方法。c、然后调用该饮料对象的taste()方法输出该饮料的味道。...
Java基础案例教程第二版答案，看完豁然开朗
目标检测专栏持续更新中，改进YOLO系列通用，适用v5、v7、v8、所有博客均是团队原创博客，所有文章禁止转载，违者必究。
07-27 6410
二、常见的并发问题 1、脏读 一个事务读取了另一个事务未提交的数据 2、不可重复读 一个事务对同一数据的读取结果前后不一致。两次读取中间被其他事务修改了 3、幻读 幻读是指事务读取某个范围的数据时，因为其他事务的操作导致前后两次读取的结果不一致。幻读和不可重复读的区别在于,不可重复读是针对确定的某一行数据而言,而幻读是针对不确定的多行数据。因而幻读通常出现在带有查询条件的范围查询中 三、事务隔离级别 1、读未提交(READ UNCOMMITTED) 可能产生脏读、不可重复读、幻读 2、读已提交(READ C
零基础Java编程题第七章
Ann_david的博客
11-04 503
函数格式 import java.util.Scanner; public class Main { public static void sum(int a, int b) { int i; int sum; sum = 0; for ( i = a; i<=b; i++) { sum += i; } System.out.println( sum ); } public static void main( String[] arg) { s
Java学习笔记
weixin_45617957的博客
06-22 355
基础学习 一、基本数据类型 基本数据类型 整数型 byte short int long 浮点型 float double 字符型 char 布尔型 boolean 引用数据类型（今后学习） 字符串、数组、类、接口、Lambda 注意事项： 字符串不是基本类型，而是引用类型。 浮点型可能只是一个近似值，并非精确的值。 数据范围与字节数不一定相关，例如float数据范围比long更加广泛，但是float是4字节，long是8字节。 浮点数当中默认类型是double。如果一定要使用float类型，需要加上一个
数据结构与算法-排序-选择排序(2)
杨得朝的博客
01-15 166
选择排序简介 简单选择排序是最简单直观的一种算法，基本思想为每一趟从待排序的数据元素中选择最小（或最大）的一个元素作为首元素，直到所有元素排完为止，简单选择排序是不稳定排序。在算法实现时，每一趟确定最小元素的时候会通过不断地比较交换来使得首位置为当前最小，交换是个比较耗时的操作。其实我们很容易发现，在还未完全确定当前最小元素之前，这些交换都是无意义的。我们可以通过设置一个变量min，每一次比较仅存储较小元素的数组下标，当轮循环结束之后，那这个变量存储的就是当前最小元素的下标，此时再执行交换操作即可。代码实
java 返回值判断_在Java中判断方法重载的条件除了参数外,还可以通过返回值类型判断。_学小易找答案...
weixin_42514752的博客
02-24 1641
【单选题】若int x;且有下面的程序片断,则输出结果是() 。 for (x=3; x<6; x++) { printf((x%2) ? "##%d" : "**%d\n", x); }【单选题】一个具体类实现接口时,需要重写接口中的( )【单选题】下列选项中,哪个关键字用来抛出异常?()【单选题】关于方法重写说法错误的( )。【判断题】在Java中判断方法重载的条件除了参数外,还...
Java零基础——docker篇
最新发布
m0_47946173的博客
11-29 2453
Docker是一个开源项目，诞生于2013年初，最初是dotCloud公司内部的一个业余项目。它基于Google公司推出的Go语言实现。项目后来加入了Linux基金会，遵从了Apache2.0协议，项目代码在GitHub上进行维护。Docker自开源后受到广范的关注和讨论，以至于dotCloud公司后来都改名为Docker Inc。RedHat已经在其RHEL6.5中集中支持Docker;Google也在其PaaS产品中广泛应用。
JAVA基础学习笔记（五）面向对象
ww981580010的博客
02-17 1302
java面向对象
Java调用微信支付功能的方法示例代码
08-18
完成基础配置后，编写启动类`Application.java`，并定义包结构，如`controller`、`service`、`impl`、`ut`等，用于分别处理控制器、业务逻辑、实现类以及单元测试。 在`controller`包下，创建处理支付请求的控制器...
Java基础入门3《IDEA使用与数据类型详解》
Alice的学习笔记
06-08 747
Hi，我又出现了，是Alice，今天我学习的是<IDEA使用与数据类型详解>，刚刚入门，肯定是先搞定各种开发工具，还一些理解性的内容，视频来源于‘蓝桥研究院’..... 本节笔记重点提要： 本节笔记重点提要： 1.Intellij Idea下载与安装 2.Intellij Idea 使用 3.使用Intellij Idea打印一个界面（案列） 4.变量 5.Java的数据类型、数据范围、符号的意义 —————————————————————————————————————————
java笔试题及答案_Java笔试题及答案
weixin_34205814的博客
02-15 1613
1.在Java中，运行如下代码段，则输出结果为( A )public static void main(String args[]){int i = 3;do{for(int j=3;j<4;++j){System.out.println("j="+i);}i++;}while(i<5);}A.j=3j=4B.j=3j=3C.什么都不输出D.j=32. 在Java中，云行如下代码，则输...
2021-05-23
Dexter7的博客
05-23 274
java笔记 java语言发展史：java5 java8力度最大 计算机进制转换：计算机全部采用二进制表示 只包含0、1两个数逢二进一 计算机程序员：Hex=16进制； DEC=10进制； OCT = 8进制； BIN = 2进制； 位（bit）： 一个数字0或者一个数字1，代表一位。 字节（Byte），每逢8位是一个字节，这是数据存储的最小单位。 1 Byta = B bit 1KB=1024Byta 1MB=1024KB 1GB=1024MB 1TB=1024GB 我们想要运行一个已有的j
leetcode--Roman to Integer
哆啦A梦的博客
06-20 461
Given a roman numeral, convert it to an integer.Input is guaranteed to be within the range from 1 to 3999.解题思路：罗马数字用几个特殊的符号表示特殊的数字，其余的数字用多个符号的左右次序表示。如果一个符号代表的数字比下一个小，则是相减。否则就是相加。public class Solution {
set --- Leedcode 448 找到所有数组中消失的数字
小柒的前端之旅
09-25 440
题目 给定一个范围在 1 ≤ a[i] ≤ n ( n = 数组大小 ) 的 整型数组，数组中的元素一些出现了两次，另一些只出现一次。 找到所有在 [1, n] 范围之间没有出现在数组中的数字。 示例: 输入: [4,3,2,7,8,2,3,1] 输出: [5,6] 解析 使用 set 剔除重复元素，再进行遍历。 var findDisappearedNumbers = function(nums) { const n = nums.length; const res = []; co
# java swing，awt图形化界面代码案例合集
weixin_54425421的博客
09-23 898
文章目录图形化界面代码案例合集形化界面代码案例合集 图形化界面代码案例合集 形化界面代码案例合集 package Demo1; import java.awt.*; public class Demo1 { public static void main(String[] args) { //创建一个窗口对象 Frame frame = new Frame("这里测试windows窗口"); //指定窗口位置，大小 frame.setL
封装，继承，多态
weixin_54425421的博客
05-25 811
文章目录封装继承supersuper Vs this方法从写多态多态的注意事项 封装 该露的露，该藏的藏 高内聚，低耦合 封装（隐藏的数据） 通常，应该禁止直接访问一个对象中的数据实际表示，而应该通过接口来访问，这称为信息隐藏 **记住这句话就够了：属性私有，get/set ** package Demo3; public class Application { public static void main(String[] args) { Student s1 =
内部类，异常及其异常处理
weixin_54425421的博客
05-27 806
文章目录内部类异常机制什么是异常异常简单分类分类2.1、Error2.2、Exception三、异常的处理方式3.1、不处理3.2、处理四、Throw 和 throws 的区别五、总结异常处理机制自定义异常实际应用中的经验总结 内部类 内部类是在类的内部定义一个类，比如A中定义一个B类，那么B类相对于A来说就是内部类，而A相对于B来说就是外部类了 成员内部类 静态内部类 局部内部类 匿名内部类 package Demo10; public class Outer { private in
# 封装，抽象类，继承，重写java编程题 问题描述 ``` 某公司的雇员分为以下若干类： Employee：这是所有员工总的父类，属性：员工的姓名,员工的生日月份。 方法：getSalary(int
weixin_54425421的博客
11-11 775
【代码】# 封装，抽象类，继承，重写java编程题 问题描述 ``` 某公司的雇员分为以下若干类： Employee：这是所有员工总的父类，属性：员工的姓名,员工的生日月份。方法：getSalary(int。
Java基础知识精讲与面试必备
"Java基础知识与面试常见问题" 在Java编程语言中，掌握基础知识点是成为一名合格的Java开发者的关键。以下是一些重要的Java基础知识及其在面试中的应用： 1. 访问修饰符：Java中，访问修饰符有private、protected...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

pofenx

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值