精华内容
下载资源
问答
  • java基础练习题
    万次阅读 多人点赞
    2020-10-21 20:03:29

    7数组操作题一       8数组操作题二

    7、数组操作题一

    现在有如下一个数组:

    int   oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5},要求将以上数组中值为0的项去掉,将不为0的值存入一个新的数组,生成的新数组为:

    int  newArr[]={1,3,4,5,6,6,5,4,7,6,7,5}

     int oldArr[] = { 1, 3, 4, 5, 0, 0, 6, 6, 0, 5, 4, 7, 6, 7, 0, 5 };
            int count = 0;
            for (int i = 0; i < oldArr.length; i++) {
                if (oldArr[i] != 0) {
                    count++;
                }
            }
            int[] newArr = new int[count];
            int a=0;
            for (int i = 0; i <oldArr.length; i++) {
                if (oldArr[i] != 0) {
                    newArr[a]=oldArr[i];
                    a++;
                }
            }
            System.out.println(Arrays.toString(newArr));
            for(int n:newArr) {
                System.out.print(n+" ");
            }
    

    8、数组操作题二

    现在给出两个数组:

    ·数组a:{1,7,9,11,13,15,17,19};

    ·数组b:{2,4,6,8,10}

    两个数组合并为数组c,按升序排列。

    public static void main(String[] args) {
    int[] a= {1,7,9,11,13,15,17,19};
    		int[] b= {2,4,6,8,10};
    		int[] c= new int[a.length+b.length];
    		System.arraycopy(a, 0, c, 0, a.length);
    		System.arraycopy(b, 0, c, a.length, b.length);
    		Arrays.sort(c);//给数组c进行升序拍序,Arrays.sort()是Arrays类的静态方法,可以直接拿来使用
    		System.out.println(Arrays.toString(c));
     	}
    
    }
    

    Java类与对象(一)

    1、编写一个Java程序,用于显示人的姓名和年龄。

    (1)定义一个类(Person)

    1. 该类中有两个属性,姓名(name)和年龄(age)。
    2. 定义构造方法,用来初始化数据成员。
    3. 提供各成员变量的getXXX()和setXXX()方法
    4. 定义display方法,将姓名和年龄打印出来。

    (2)定义MainClass类,在main方法中创建人类的实例,然后将信息显示。

    package work;
    
    
    public class Person {
        private String name;
        private Integer age;
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public Person(String name, Integer age) {
            this.name = name;
            this.age = age;
        }
    }
    
    package work;
    
    public class MainClass {
        public void person(){
            Person person=new Person("张三",21);
            person.display();
        }
        public static void main(String[] args) {
            MainClass mainClass=new MainClass();
            mainClass.person();
    
    
        }
    }

    2、构造方法与重载

    (1)定义一个类WuMingFen(无名的粉)

    (2)该类有三个属性:粉名:String name; 粉的分量(两):int quantity ;是否带汤:boolean likeSoup

    (3)构造方法1:含三个参数,为三个属性赋值。

    (4)构造方法2:含两个参数,为前两个属性赋值

    (5)构造方法3:不含参数的构造方法,完成属性的初始化为:.粉名:酸辣面;分量:2两;是否带汤:带汤。

    (6)写一个普通方法:String check(),方法的功能:用字符串连接符连接该类的三个属性并返回一个字符串,例如:“牛肉粉、2两、不带汤”。

    (7)定义一个主类,分别调用类WuMingFen的3个构造方法完成3个对象的创建,并调用check方法,输出其方法的返回值。

    package work;
    //(1)定义一个类WuMingFen(无名的粉)
    public class WuMingFen {
        //(2)该类有三个属性:粉名:String name; 粉的分量(两):int quantity ;是否带汤:boolean likeSoup
        private String name;
        private  int quantity;
        private boolean likeSoup;
    
        //(3)构造方法1:含三个参数,为三个属性赋值。
        public WuMingFen(String name, int quantity, boolean likeSoup) {
            this.name = name;
            this.quantity = quantity;
            this.likeSoup = likeSoup;
        }
        //(4)构造方法2:含两个参数,为前两个属性赋值
        public WuMingFen(String name, int quantity) {
            this.name = name;
            this.quantity = quantity;
        }
        //(5)构造方法3:不含参数的构造方法,完成属性的初始化为:.粉名:酸辣面;分量:2两;是否带汤:带汤。
        public WuMingFen() {
            name="酸辣粉";
            quantity=2;
            likeSoup=true;
        }
        //(6)写一个普通方法:String check(),方法的功能:用字符串连接符连接该类的三个属性并返回一个字符串,例如:“牛肉粉、2两、不带汤”。
        public String check(){
            return name+quantity+likeSoup;
        }
    
        public static void main(String[] args) {
        //(7)定义一个主类,分别调用类WuMingFen的3个构造方法完成3个对象的创建,并调用check方法,输出其方法的返回值。
            WuMingFen wuMingFen1=new WuMingFen("牛肉粉",1,true);
            WuMingFen wuMingFen2=new WuMingFen("羊肉汤",2);
            WuMingFen wuMingFen3=new WuMingFen();
            wuMingFen1.check();
            wuMingFen2.check();
            wuMingFen3.check();
            System.out.println(wuMingFen1.check());
            System.out.println(wuMingFen2.check());
            System.out.println(wuMingFen3.check());
        }
    
    }

    4、this的用法

    class Student {
    
    public Student() {
    
    System.out.println("无参的构造方法");
    
    }
    
    public Student(String name) {
    
    this();
    
    System.out.println("一个参数的构造方法");
    
    }
    
    public Student(String name, int age) {
    
    this(name);
    
    System.out.println("两个参数的构造方法");
    
    }
    
    }

    2、定义Example06类,代码如下所示:

    public class Example06 {
    
    public static void main(String[] args) {
    
    Student s1 = new Student("Jack", 22);
    
    }
    
    }
    无参的构造方法
    一个参数的构造方法
    两个参数的构造方法
    

    5、家族姓氏(static的用法)

    源文件名称:FamilyPerson.java

    类名:FamilyPerson  

    属性

    变量名

    含义

    数据类型

    surname

    String

    name

    String

    方法

    方法名

    含义

    返回值类型含义

    setSurname

    设置姓

    void

    setName

    设置名

    void

    源文件名称:MainClass.java

    类名:MainClass  (主类,即应用程序)

    main方法

    完成任务

    1.实例化三个对象,一个父亲father,一个大儿子sonone,一个二儿子sontwo

    2.调用setSurname为姓赋值(例如:张、李、王)

    3.调用setName为三个对象的名赋值

    4.显示三个对象的姓名

    5. 调用setSurname给父亲、大儿子、二儿子改姓

    6.再次显示三个对象的姓名

    备注

    第2步和第5步的代码不完全相同,思考一下。

    package work;
    
    public class FamilyPerson {
        private String surname;
        private String name;
    
        public void setSurname(String surname) {
            this.surname = surname;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return surname+name;
        }
    }
    package work;
    
    public class MainClass {
        static String surname;
        public static void main(String[] args) {
            //1.实例化三个对象,一个父亲father,一个大儿子sonone,一个二儿子sontwo
            FamilyPerson father=new FamilyPerson();
            FamilyPerson sonone=new FamilyPerson();
            FamilyPerson sontwo=new FamilyPerson();
            //2.调用setSurname为姓赋值(例如:张、李、王)
            father.setSurname("张");
            sonone.setSurname("李");
            sontwo.setSurname("王");
            //3.调用setName为三个对象的名赋值
            father.setName("爸爸");
            sonone.setName("明明");
            sontwo.setName("天天");
            //4.显示三个对象的姓名
            System.out.println(father);
            System.out.println(sonone);
            System.out.println(sontwo);
            //5. 调用setSurname给父亲、大儿子、二儿子改姓
            surname="赵";
            father.setSurname(surname);
            sonone.setSurname(surname);
            sontwo.setSurname(surname);
            //6.再次显示三个对象的姓名
            System.out.println(father);
            System.out.println(sonone);
            System.out.println(sontwo);
        }
    
    }

    4、Tank战斗场景:根据下面表中对类的描述写出类的源码。

    源文件名称:Tank.java

    类名:Tank   (坦克)

    属性

    变量名

    含义

    数据类型

    speed

    速度

    double

    bulletAmount

    炮弹数量

    int

    color

    坦克颜色

    (所有坦克的颜色都一致,若一个坦克颜色改变则都改变)

    char

    方法

    方法名

    含义

    返回值含义

    speedUp(int x)

    加速到x公里/小时(最高时速不能超过200,若超过,给出提示,并自动降为200)

    void

    speedDown(int x)

    减速到x公里/小时

    void

    setBulletAmount(int x)

    设置炮弹数量

    void

    getSpeed()

    获取坦克当前的速度

    当前速度

    getBulletAmount()

    获取炮弹当前的数量

    当前炮弹数量

    fire()

    开火(每开火一次,发射一枚炮弹)

    void

    conFire(int x)

    连续开火(连续发射,共计x枚炮弹,注意连续开火也是一枚枚发射出去的,而不是一次发射x枚)

    void

    setColor(char x)

    将坦克颜色设置为x色

    void

    brake()

    刹车(速度降为0)

    void



    源文件名称:Fight.java

    类名:Fight   (主类,即Java应用程序)

    main方法完成任务

    1.实例化两个坦克对象

    2.实现加速、设置炮弹数量、设置所有坦克颜色为绿色功能

    3.开火

    4.减速

    5.设置坦克颜色为黄色(与2中不同,用另一种方法实现对颜色属性的改变)

    6.连续开火

    每次执行一次动作后,都需要用System.out.println输出坦克类的相关属性值以验证是否被改变。开火后,当炮弹数量为0时,坦克就立即刹车。

    package work;
    
    public class Tank {
        protected double speed;
        protected int bulletAmount;
        protected char color;
    
        public void speedUp(int x) {
            this.speed = x;
            speed++;
            if (x > 200) {
                System.out.println("最高时速不能超过200公里/小时!");
                speed--;
            }
            System.out.println("速度为:" + x);
        }
    
        public void speedDown(int x) {
            this.speed = x;
            speed--;
    
        }
    
        public void setBulletAmount(int x) {
            this.bulletAmount = x;
    
        }
    
        public double getSpeed() {
            return speed;
    
        }
    
        public int getBulletAmount() {
            return bulletAmount;
    
        }
    
        public void fire() {
            bulletAmount--;
    
        }
    
        public void conFire(int x) {
            this.bulletAmount = x;
            if (x > 0) {
                x--;
            }
        }
    
        public void setColor(char x) {
            this.color = x;
        }
    
        public char getColor() {
            return color;
        }
    
        public void brake() {
            speed = 0;
    
        }
    }
    
    
    package work;
    
    public class Fight {
    
        public static void main(String[] args) {
            Tank t1=new Tank();
            Tank t2=new Tank();
            t1.speedUp(300);
            t1.speedUp(188);
            t1.setBulletAmount(10);
            t1.setBulletAmount(12);
            t1.setColor('绿');
            t1.fire();
            t1.speedDown(150);
            t2.setColor('黄');
            t2.conFire(12);
            if(t1.bulletAmount>0){
                t1.brake();
            }
            if(t2.bulletAmount>0){
                t2.brake();
            }
            System.out.print(t1.speed);
            System.out.println(t1.color);
            System.out.println(t2.color);
            System.out.print(t2.speed);
        }
    
    }

    Java类与对象基础选择题库(11.4)

    1.作为Java应用程序入口的main方法,其声明格式是()

    A.public static int main(String args[])      B.public static void main(String args[])

    C.public void main(String args[])         D.public int main(String args[])   

    2.有一个类A,对于其构造方法的声明正确的是()。

    A.void A(int x){…}     B.public A(int x){…}    

     C.A A(int x){…}        D.int A(int x){…}

    3. 方法的形参()。

    A.可以没有 B.至少有一个

    C.必须定义多个形参      D.至少有两个

    4.编译并运行下面的程序,运行结果是()。

    public class A{

       public static void main(String args[]){

          A a=new A();

          a.method(8);

       }

       void method(int i){

          System.out.println(“int:  ”+i);

       }

       void method(long i){

          System.out.println(“long:  ”+i);

       }

    A.程序可以编译运行,输出结果为:“int:  8”    

    B.程序可以编译运行,输出结果为:“long:  8”    

    C.程序有编译错误,因为两个method()方法必须定义为静态(static)的

    D.程序可以编译运行,但是没有输出

    5.构造方法在(   )时被调用。

    A.类定义时 B.使用对象的变量时

    C.调用对象方法时                             D.创建对象时

    6.定义类A如下:

    class A{

      int a,b,c;

      public void B(int x,int y, int z){ a=x;b=y;c=z;}

    }

    下面对方法B的重载哪些是正确的()。

    A.public void A(int x1,int y1, int z1){ a=x1;b=y1;c=z1;}

    B.public void B(int x1,int y1, int z1){ a=x1;b=y1;c=z1;}

    C.public void B(int x,int y){ a=x;b=y;c=0;}     

    D.public B(int x,int y, int z){ a=x;b=y;c=z;}

    7.下面哪个包是编程时不需要导入就可以直接使用的    

    A.java.net B.java.lang C.java.sql D.java.util

    8.当方法中的局部变量与成员变量同名时,必须使用下列哪一个关键字指出成员变量   。

    A.static B.super C.this D.new

    9.下列类的声明中不合法的是    

    A.class People(){…} B.class 植物{…}

    C.class A{…} D.public class 共有类{…}

    10.能作为类的修饰符, 也能作为类成员的修饰符的是    

    A.public B.extends C.Float D.static

    11.试完成下述程序片段   

    public class Point{

    int x,y;

    public  Point(int x,int y){

    (   )=x;

    (   )=y;

           }

    }

    A.Point.x   Point.y B.this.x   this.y

    C.super.x  super.y D.无解

    12.重载指的是方法具有相同的名字,但这些方法的参数必须不同。下列哪种说法不属于方法参数的不同    

    A.形式参数的个数不同。 B.形式参数的类型不同。

    C.形式参数的名字不同。 D.形式参数类型的排列顺序不同。

    13. 关于类的命名,正确说法是(    )多选

    A.  可以由数字和英文拉丁字母组成,且可以任意排序

    B.  命名要做到见名知意

    C.  如果是由多个单词组成,每个单词首字母大写

    D.  可以是Java已经定义过的关键字

    14. 类中某方法定义如下:

    Double fun(int a,int b){

    return a*1.0/b;

    }

    同一类内其它方法调用该方法的正确方式是(    )

    A. double a=fun(1,2);

    B.  double a =fun(1.0,2.0);

    C.  int x =fun(1,2); 

    D.  int x=fun(1.0,2.0);

    15. 给定java代码,如下,编译运行,结果是(    )

    public static void main(String[] args){

    boolean flag;

    System.out.println(“flag”+flag); //局部变量需要先初始化再使用

    }

    A. 编译错误

    B.  编译通过,单出现运行时错误

    C.  正常运行,输出flag=false

    D.  正常运行,输出flag=

    16.下列构造方法的调用方式中,正确的是(     )

    A.按照一般方法调用           B.由用户直接调用

    C.只能通过new自动调用       D.被系统调用

    17.int型public成员变量MAX_LENGTH,该值保持为常数100,则定义这个变量的语句是(       )。 

    A.public  int  MAX_LENGTH=100    B.final  int  MAX_LENGTH=100

    C.public const int MAX_LENGTH=100  D.public  final  int MAX_LENGTH=100

    18.下列哪个修饰符可以使在一个类中定义的成员变量只能被同一包中的类访问?(       )。

    A.private    B.无修饰符     C.public    D.protected

    19.给出下列代码,如何使成员变量m 被方法fun()直接访问?(       )。

    class Test

    {  private  int  m;

       public  static  void  fun()

       {   ...   }    }

    A.将private int m 改为protected int m

    B.将private int m 改为 public int m

    C.将private int m 改为 static int m

    D.将private int m 改为 int m

    20.已知有下列类的说明,则下列哪个语句是正确的?(      )。

    public class Test

    {  private  float  f = 1.0f;

       int m = 12;

       static int n=1;

       public static void main(String arg[])

       {  Test t = new Test();  }      }

    A.t.f;     B.this.n;     C.Test.m;     D.Test.f;

    21.给出下列代码,则数组初始化中哪项是不正确的?(       )。

    byte[]array1,array2[];

    byte array3[][];

    byte [][] array4;

    A.array2 = array1        B.array2=array3

    C.array2=array4          D.array3=array4

    22.下列代码的执行结果是(       )。 

    public class Test

    {  public  int  aMethod()

       {  static  int i=0;        i++;    System.out.println(i);   }

       public static void main(String args[])

       {  Test  test = new Test();    test.aMethod(); }     }

    A.编译错误   B.0     C.1      D.运行成功,但不输出

    23.为AB类的一个无形式参数无返回值的方法method书写方法头,使得使用类名AB作为前缀就可以调用它,该方法头的形式为(       )。

    A.static void method( )            B. public void method( )   

    C.final void method( )             D. abstract void method

    24.设有下面的一个类定义:(多选题

    class AA {  static void Show( )  { System.out.println(“我喜欢Java!”); }  }

    class BB {   void Show( )      { System.out.println(“我喜欢C++!”); }  }

    若已经使用AA类创建对象a和BB类创建对象b,则下面(      )方法调用是正确的。

       A. a.Show( ) ; b.Show( )        B. AA.Show( ); BB.Show( );                            

       C. AA.Show( ); b.Show( );     D. a.Show( ); BB.Show( );                         

    25.在Java中,一个类可同时定义许多同名的方法,这些方法的形式参数的个数、类型或顺序各不相同,传回的值也可以不相同。这种面向对象程序特性称为(     )。

      A.隐藏         B.覆盖       C.重载       D.Java不支持此特性

    1 B.public static void main(String args[])  2构造方法没有返回值类型B.public A(int x){…}   
    3. 方法的形参()。A.可以没有 4A.程序可以编译运行,输出结果为:“int:  8”    5 D.创建对象时
    6重载 方法名相同,方法体不同,参数列表不同C.public void B(int x,int y){ a=x;b=y;c=0;}   
    7 B.java.lang  8C.this    9A (但是我搜的c也不对) 10A.public    三种类的修饰符public、abstract、final  11 B.this.x   this.y 12C.形式参数的名字不同。
    13 B.  命名要做到见名知意 C.  如果是由多个单词组成,每个单词首字母大写 
    14A.    double a=fun(1,2); 15A. 编译错误 16C.只能通过new自动调用 
    17 D.public  final  int MAX_LENGTH=100 (不严谨应该加static)       18B. 19C.将private int m 改为 static int m        20  A.t.f;B.static方法中不能使用this, C D m和f都不是静态成员不能用类名点成员方式访问, A t是一个对象,可以用对象点方法名或者变量名        

    21A.array2 = array1 (题目出的不太好这里没有初始化会报错,但是抛开这些判断a1是一维数组,其他是二维数组..
    22A.编译错误 1.public  int  aMethod()方法没有返回值,2主要原因 java是面向对象的不用像c一样,static不能写在局部变量里面
    23A 1、public修饰的方法可被其它类访问或引用。2、abstract修饰的方法是抽象方法,抽象方法没有方法体,要使用抽象方法,必须先实现此抽象方法。3、final修饰的方法不能被继承。
    4、static修饰的方法为静态方法,静态方法不需要类的实例化就可以被类直接调用。故要使得类名AB可以直接调用method()方法,则必须在method()前用static来修饰。  24AC  25 C.重载 

    更多相关内容
  • Java基础练习题由本人整理并上传,非常适合于初学者加强巩固自己的知识,编程学好的唯一途径就是多练习。
  • JAVA基础练习题

    2018-01-10 11:34:38
    JAVA基础练习题,可快速提高JAVA基础知识,让你迅速掌握开发技能。
  • Java基础练习题及详细答案

    万次阅读 多人点赞 2020-08-20 12:01:50
    本篇文章给大家安利一些关于 Java 基础练习题,每道题都附有答案链接,答案解题的每个步骤到运行结果都十分详细,十分适合小白拿来练习,也十分适合准备面试的各位复习下 Java 基础,这篇文章我会不断更新,题目都...

    本文参考 嗨客网 Java 实战

    前言

    本篇文章给大家安利一些关于 Java 基础的练习题,每道题都附有答案链接,答案解题的每个步骤到运行结果都十分详细,十分适合小白拿来练习,也十分适合准备面试的各位复习下 Java 基础,这篇文章我会不断更新,题目都是对应 Java 基础中的各个知识点,大家在学习了Java 基础之后,做几道相关的练习题,复习一下该知识点,在学习过程中,觉得十分抽象、晦涩难懂的知识点,配合一道案例题,或许会有意想不到的效果哦!
     

    目录

    Java入门

    • Java HelloWorld
    • Java注释

    Java变量

    • 01 Java变量定义
    • 02 Java数据类型
    • 03 Java变量运算
    • 04 Java变量运算
    • 05 Java常量

    Java三元运算符

    • 01 Java三元运算符
    • 02 Java三元运算符
    • 03 Java三元运算符

    Java条件判断

    • 01 Java if条件判断
    • 02 Java if条件判断
    • 03 Java switch
    • 04 Java switch
    • 05 Java switch

    Java循环

    • 01 Java for循环
    • 02 Java for循环
    • 03 Java for循环
    • 04 Java for循环
    • 05 Java for循环嵌套
    • 06 Java for循环嵌套
    • 07 Java break
    • 08 Java continue
    • 09 Java while循环
    • 10 Java do while循环
    • 11 Java死循环

    Java随机数

    • 01 Java随机数
    • 02 Java随机数
    • 03 Java随机数

    Java数组

    • 01 Java定义数组
    • 02 Java遍历数组
    • 03 Java数组
    • 04 Java数组

    Java方法

    • 01 Java方法
    • 02 Java方法
    • 03 Java逢七过游戏

    2020.08.20更,未完待续。。。。。

     

    正文:Java基础练习题

    Java入门

    题目一

    题目:使用 Java 实现,编写第一个程序,即 Java HelloWorld。

    答案:https://haicoder.net/case/java/java-helloworld.html

    题目二

    题目:使用 Java 的注释,包括单行注释和多行注释。

    答案:https://haicoder.net/case/java/java-descripotion.html

    Java变量

    题目一

    题目:Java变量定义,分别定义 Java 的 8 种 基本数据类型 的变量。

    答案:https://haicoder.net/case/java/java-variable.html

    题目二

    题目:Java数据类型,选用 Java 合适的数据类型定义变量。

    答案:https://haicoder.net/case/java/java-datatype.html

    题目三

    题目:Java变量运算,运用 Java 变量计算圆柱体积。

    答案:https://haicoder.net/case/java/java-variable-operator.html

    题目四

    题目:Java变量运算,运用 Java 变量根据父母身高预测出子女身高。

    答案:https://haicoder.net/case/java/java-variable-operator2.html

    题目五

    题目:Java 常量,完成 Java 常量的基本使用。

    答案:https://haicoder.net/case/java/java-contants.html

    Java三元运算符

    题目一

    题目:Java三元运算符,运用 Java 三元运算符进行运算。

    答案:https://haicoder.net/case/java/java-ternary-operator.html

    题目二

    题目:Java三元运算符,某小伙想定一份外卖,商家的优惠方式如下:鱼香肉丝单点 24 元,油炸花生米单点 8 元,米饭单点 3 元。订单满 30 元 8 折优惠。鱼香肉丝优惠价 16 元,但是优惠价和折扣不能同时使用。那么这个小伙要点这三样东西,最少要花多少钱?

    答案:https://haicoder.net/case/java/java-ternary-operator2.html

    题目三

    题目:Java三元运算符,运用 Java 三元运算符获取几个数中的最大值。键盘录入三位同学的年龄,用程序实现获取这三个同学的最大年龄。

    答案:https://haicoder.net/case/java/java-ternary-operator3.html

    Java条件判断

    题目一

    题目:Java if条件判断,李雷想买一个价值 7988 元的新手机,他的旧手机在二手市场能卖 1500 元,而手机专卖店推出以旧换新的优惠,把他的旧手机交给店家,新手机就能够打 8 折优惠。

    答案:https://haicoder.net/case/java/java-if.html

    题目二

    题目:Java if条件判断,根据用户输入的年龄,判断用户属于哪个年龄段。

    答案:https://haicoder.net/case/java/java-if2.html

    题目三

    题目:Java switch,键盘录入一个 0 到 7 数字,使用 switch 输出这个数字对应的星期。

    答案:https://haicoder.net/case/java/java-switch.html

    题目四

    题目:Java switch,键盘录入一个月份数字,使用 switch 输出这个月份对应的季节。

    答案:https://haicoder.net/case/java/java-switch2.html

    题目五

    题目:Java switch,用户输入星期数,使用 Java switch 匹配显示对应的运动项目。输入星期数,显示今天的运动项目,周一跑步、周二游泳、 周三慢走、 周四单车、 周五爬山、周六拳击、周日休息。

    答案:https://haicoder.net/case/java/java-switch3.html

     

    Java流程控制

    题目一

    题目:Java for循环,在中国历法中有十二生肖年份,2019 年是己亥猪年,请在控制台输出从 1949 年(包含)到 2019 年(包含)中所有是猪年的年份。

    答案:https://haicoder.net/case/java/java-for.html

    题目二

    题目:Java for循环,中国使用的公历有闰年的说法,闰年的规则是:四年一闰,百年不闰,四百年再闰。(年份能够被 4 整除但不能被 100 整除算是闰年,年份能被 400 整除也是闰年)。请打印出 2000 年到 2019 年的所有闰年年份。

    答案:https://haicoder.net/case/java/java-for2.html

    题目三

    题目:Java for循环,计算出 1~100 之间的偶数和,并把求和结果在控制台输出 。

    答案:https://haicoder.net/case/java/java-for3.html

    题目四

    题目:Java for循环,请输出所有 “水仙花数” 。“水仙花数” 指的是一个三位数,个位、十位、百位的数字立方和等于原数本身。

    例如:153 333 + 555 + 111 = 153。

    答案:https://haicoder.net/case/java/java-for4.html

    题目五

    题目:Java for循环嵌套,使用 for 循环语句,在控制台打印出一个四行五列的长方形,效果如下:

    @@@@@
    @@@@@
    @@@@@
    @@@@@

    答案:https://haicoder.net/case/java/java-for-nest.html

    题目六

    题目:Java for循环嵌套,使用 for 循环语句,在控制台打印出一个五行的三角形,效果如下:

    @
    @@
    @@@
    @@@@
    @@@@@

    答案:https://haicoder.net/case/java/java-for-nest02.html

    题目七

    题目:Java break,运用 break 结束当前循环 ,计算 1、2、3、4、5 这一组数据,但要求只计算前 3 个数的和。

    答案:https://haicoder.net/case/java/java-break.html

    题目八

    题目:Java continue,运用 continue 跳过当前循环 ,计算 1、2、3、4、5 这一组数据,但要求只计算 1、2、3、5 的和。

    答案:https://haicoder.net/case/java/java-continue.html

    题目九

    题目:Java while循环,运用 Java while 循环 计算出 1 到 10 的和。

    答案:https://haicoder.net/case/java/java-while.html

    题目十

    题目:Java do while循环,运用 Java do while循环 计算出 1 到 10 的和。

    答案:https://haicoder.net/case/java/java-do-while.html

    题目十一

    题目:Java 死循环,利用死循环,持续获取用户输入。(应用场景如:持续输入每一个学生成绩)

    答案:https://haicoder.net/case/java/java-dead-cycle.html

     

    Java随机数

    题目一

    题目:Java随机数,运用 Java 的 Random 得到随机数,获取 0 到 9 内的随机数(包括 0 和 9)。

    答案:https://haicoder.net/case/java/java-random.html

    题目一

    题目:Java随机数,运用 Java 的 Random 函数得到区间随机数。

    1. 生成一个 1-10 之间的随机数。
    2. 生成一个 3-15 之间的随机数。
    3. 生成一个 5-999 之间的随机数。

    答案:https://haicoder.net/case/java/java-random2.html

    题目二

    题目:Java随机数,运用 Java 的 Random 函数实现猜数字游戏。

    随机产生一个 1-100 之间的数字,然后让玩家不断猜测,如果猜大,提示过大,如果猜小,提示过小,如果猜中则程序停止。

    答案:https://haicoder.net/case/java/java-random3.html

     

    Java数组

    题目一

    题目:Java定义数组,Java 数组 的定义格式分别为:静态初始化、动态初始化,使用静态初始化和动态初始化定义数组。

    答案:https://haicoder.net/case/java/java-array-init.html

    题目二

    题目:Java遍历数组,请使用静态初始化的方式,创建一个长度为 5 的整数数组,并为数组中的元素赋值,遍历数组,在同一行打印所有元素,元素之间用空格隔开,比如:如果数组为 { 1,2,3,4,5 } 则打印结果为:1 2 3 4 5。

    答案:https://haicoder.net/case/java/java-arrary-walk.html

    题目三

    题目:Java 数组 ,创建一个长度为 6 的整数数组,随机生成六个 0 (包含) - 100 (不包含) 之间的整数存放到数组中,然后计算出数组中所有元素的和并打印。

    答案:https://haicoder.net/case/java/java-array.html

    题目四

    题目:Java数组,运用 Java 数组 存储学生成绩,遍历数组 得出成绩最高的学生。

    答案:https://haicoder.net/case/java/java-array2.html

     

    Java方法

    题目一

    题目:Java 方法 ,定义一个方法,该方法能够找出三个 整数 中的最大值并返回。

    答案:https://haicoder.net/case/java/java-method.html

    题目二

    题目:Java 方法 ,数字是有绝对值的,负数的绝对值是它本身取反,非负数的绝对值是它本身。请定义一个方法,方法能够得到小数 类型 数字的绝对值并返回。

    答案:https://haicoder.net/case/java/java-method2.html

    题目三

    题目:Java 方法 ,使用 Java 实现逢七过这个游戏,游戏规则如下:从 1 到 20 开始报数,当玩家要报的数字包含 7 或者是 7 的倍数时都要说:过。

    答案:https://haicoder.net/case/java/java-method3.html

     

    彩蛋

    Java 基础练习题内容,剩下的题目我会继续更新,先提前小小的剧透一下后面的内容哦!
    www.haicoder.net
    你以为到这里就结束了吗?还有Java基础增强的习题,奉上大纲:
    www.haicoder.net
    但是因为文章数量过多,整理不易,所以如果更新过慢,请大家谅解,文章我会尽自己最大速度更新,大家可以先关注我,或者收藏下这篇文章,我会持续更新的,以上案例是提供给有一定 Java 基础的同学看的,如果感觉做题有些压力,可以先到各类教程网学习Java,本人这里当然首推上方习题及答案来源的 嗨客网

    更多

    更多精选文章,可以关注下方公众号:

    嗨客网(www.haicoder.net)

    展开全文
  • java基础练习题.zip

    2020-04-30 09:49:26
    在学习了JAVA基础篇的文章。以及老师讲课的内容,有没有兴趣做一些基础的题目呢。如有雷同‘纯属巧合’
  • Java基础练习题以及解析答案,适用于初学者学习,使初学者更好的了解Java,测试近期水平的学习状况。此测试题涉及到Java基础以及面向对象的一部分内容
  • java基础练习题

    2014-10-22 13:54:00
    这回30道java编程,很是适合大多数练习使用
  • JAVA基础练习,填空和选择为主,适合新人学习
  • Java基础学习练习题,语言基础篇~

    参考:

    1. 变量的练习:

      • 声明一个变量,一次声明多个变量。

      • 声明变量直接初始化,先声明变量,而后再给变量初始化。

      • 声明整型变量g,声明另一个整型变量h并赋值为h+10,输出变量h的值。

      • 声明整型变量i,在i本身基础之上增10,输出变量i的值。

      • 声明一些正确的和错误的变量名。

      参考案例:

      //变量的演示
      public class VarDemo {
          public static void main(String[] args) {
              //1)变量的声明:----相当于在银行开帐户
              int a; //声明一个整型的变量,名为a
              int b,c,d; //声明三个整型的变量,名为b,c,d
              //int a; //编译错误,变量不能同名
      
              //2)变量的初始化:----相当于给帐户存钱
              int e = 250; //声明整型变量e并赋值为250
              int f;   //声明整型变量f
              f = 250; //给f赋值为250
      
              //3)变量的使用:----使用的是帐户里面的钱
              int g = 5;
              int h = g+10; //取出g的值5,加10后,再赋值给变量h
              System.out.println(h); //输出变量h的值15
              System.out.println("h"); //输出h,双引号中的原样输出
              g = g+10; //在g本身基础之上增10
              System.out.println(g); //输出g的值15
      
              //int i = 3.14; //编译错误,数据类型必须匹配
              //System.out.println(j); //编译错误,变量j未声明
              int j;
              //System.out.println(j); //编译错误,变量j未初始化
      
              //4)变量的命名:
              int a1,a_5$,_3c,$_b;
              //int a*b; //编译错误,不能包含*号等特殊符号
              //int 1a; //编译错误,不能以数字开头
              int aa = 5;
              //System.out.println(aA); //编译错误,严格区分大小写
              //int class; //编译错误,不能使用关键字
      
              //int k; //不直观,不建议
              //int 年龄; //允许,但不建议
              //int nianLing; //既不直观也不专业,必须杜绝
              int age; //建议"英文的见名知意"
              int score,myScore,myJavaScore; //建议"小驼峰命名法"
      
          }
      }
      
    2. 基本数据类型的练习:int

      • 声明初始化两个以上整数变量,并且输出两个整数变量的除法结果
      • 声明两个很大的变量,然后相加,输出运算结果,测试运算溢出现象

      参考案例:

      //1)int:整型,4个字节,-21个多亿到21个多亿
      int a = 25; //25为整数直接量,默认为int类型
      //int b = 10000000000; //编译错误,100亿默认为int类型,但超出int范围了
      System.out.println(5/2);   //2
      System.out.println(2/5);   //0
      System.out.println(5/2.0); //2.5
      int c = 2147483647; //int的最大值
      c = c+1;
      System.out.println(c); //-2147483648(int的最小值),发生溢出了,需要避免
      
    3. 基本数据类型的练习:long

      • 声明初始化两个以上的长整型变量
      • 声明变量存储几个较大数据的运算,演示:若有可能溢出建议将L设计在第1个数字后。

      参考案例:

      //2)long:长整型,8个字节,很大很大很大
      long a = 25L; //25L为长整型直接量,默认为long型
      //long b = 10000000000; //编译错误,100亿默认为int类型,但超出int范围了
      long c = 10000000000L; //100亿L为长整型直接量
      
      long d = 1000000000*2*10L;
      System.out.println(d); //200亿
      long e = 1000000000*3*10L;
      System.out.println(e); //不是300亿
      long f = 1000000000L*3*10;  //运算若有可能溢出,建议在第1个数字后加L
      System.out.println(f); //300亿
      
    4. 基本数据类型的练习:double

      • 声明初始化两个以上的浮点型变量
      • 声明几个浮点型变量并将它们做数学操作,演示double运算的舍入误差问题

      参考案例:

      //3)double:浮点型,8个字节,很大很大很大
      double a = 3.14159; //3.14159为浮点数直接量,默认为double类型
      float b = 3.14159F; //3.14159F为float型-----了解即可
      
      double c=6.0,d=1.9;
      System.out.println(c-d); //0.10000000000000009,有可能发生舍入误差
      
    5. 基本数据类型的练习:boolean

      • 声明初始化两个以上的布尔型变量

      参考案例:

      //4)boolean:布尔型,1个字节
      boolean a = true;  //true为布尔型直接量
      boolean b = false; //false为布尔型直接量
      //boolean c = 25; //编译错误,布尔型只能赋值为true或false
      
    6. 基本数据类型的练习:char

      • 声明初始化五个以上的字符型变量
      • 声明字符型变量,演示转义符

    参考案例:

       //5)char:字符型,2个字节
       char c1 = '女'; //字符女
       char c2 = 'f';  //字符f
       char c3 = '6';  //字符6
       char c4 = '*';  //字符*
       //char c5 = 女; //编译错误,字符型直接量必须放在单引号中
       //char c6 = ''; //编译错误,必须有字符
       //char c7 = '女性'; //编译错误,只能有一个字符
       
       char c8 = '\\';
       System.out.println(c8);
    
    1. 基本数据类型的转换:两种方式

      • 声明几个变量,演示自动类型转换和强制类型转换的语法
      • 声明一个较大类型的长整型变量,演示强转可能会发生的溢出问题
      • 声明一个较大精度的浮点型变量,演示强转可能会发生的丢失精度问题

      参考案例:

      int a = 5;
      long b = a;     //自动类型转换
      int c = (int)b; //强制类型转换
      
      long d = 5; //自动类型转换
      double e = 5; //自动类型转换
      
      long f = 10000000000L;
      int g = (int)f;
      System.out.println(g); //1410065408,强转有可能发生溢出
      double h = 25.987;
      int i = (int)h;
      System.out.println(i); //25,强转有可能丢失精度
      
    2. 基本数据类型的转换:两点规则

      • 声明两个byte型变量b1和b2,并赋值为直接量
      • 声明一个byte型变量,并赋值为b1与b2的和

      参考案例:

      byte b1 = 5;
      byte b2 = 6;
      byte b3 = (byte)(b1+b2);
      
      System.out.println(2+2);     //4
      System.out.println(2+'2');   //52,2加上'2'的码50
      System.out.println('2'+'2'); //100,'2'的码50,加上'2'的码50
      
    3. 运算符的练习:算术

      • 输出几个整数取模,验证结果
      • 声明两个整型变量,演示单独使用时的自增和自减
      • 声明几个整型变量,演示被使用时的自增和自减

      参考代码:

      System.out.println(5%2); //1,商2余1
      System.out.println(8%2); //0,商4余0----整除
      System.out.println(2%8); //2,商0余2
      
      //单独用----自增
      int a=5,b=5;
      a++; //相当于a=a+1
      ++b; //相当于b=b+1
      System.out.println(a); //6
      System.out.println(b); //6
      
      //单独用----自减
      int a=5,b=5;
      a--; //相当于a=a-1
      --b; //相当于b=b-1
      System.out.println(a); //4
      System.out.println(b); //4
      
      //被使用----自增
      int a=5,b=5;
      int c = a++; //1)将a++的值5赋值给c  2)a自增1变为6
      int d = ++b; //1)将++b的值6赋值给d  2)b自增1变为6
      System.out.println(a); //6
      System.out.println(b); //6
      System.out.println(c); //5
      System.out.println(d); //6
      
      //被使用----自减
      int a=5,b=5;
      int c = a--; //1)将a--的值5赋值给c  2)a自减1变为4
      int d = --b; //1)将--b的值4赋值为d  2)b自减1变为4
      System.out.println(a); //4
      System.out.println(b); //4
      System.out.println(c); //5
      System.out.println(d); //4
      
    4. 运算符的练习:关系

    • 声明几个变量,演示最基本的>,<,>=,<=,==,!=操作
    • 演示关系运算符和算术运算符联合使用的效果

    参考代码:

    int a=5,b=10,c=5;
    boolean b1 = b>a;
    System.out.println(b1);   //true
    System.out.println(c<b);  //true
    System.out.println(a>=c); //true
    System.out.println(b<=a); //false
    System.out.println(b==c); //false
    System.out.println(a!=c); //false
    
    System.out.println(a+c>10); //false
    System.out.println(b%2==0); //true
    System.out.println(c++>5);  //false------c自增1变为6
    System.out.println(c++>5);  //true-------c自增1变为7
    
    1. 运算符的练习:逻辑
    • 声明三个整型变量,演示&&和||,演示!
      • &&的演示要求:true+false、false+true、true+true、false+false
      • ||的演示要求:true+false、false+true、true+true、false+false
      • !的演示要求:true、false
    • 演示短路&&与短路||

    参考代码:

    int a=5,b=10,c=5;
    //演示&&
    boolean b1 = b>=a && b<c;
    System.out.println(b1);          //true&&false=false
    System.out.println(b<=c && b>a); //false&&true=false
    System.out.println(a==b && c>b); //false&&false=false
    System.out.println(b!=c && a<b); //true&&true=true
    //演示||
    System.out.println(b>=a || b<c); //true||false=true
    System.out.println(b<=c || b>a); //false||true=true
    System.out.println(b!=c || a<b); //true||true=true
    System.out.println(a==b || c>b); //false||false=false
    //演示!
    boolean b2 = !(a<b);
    System.out.println(b2);     //!true=false
    System.out.println(!(a>b)); //!false=true
    
    //演示&&的短路
    int a=5,b=10,c=5;
    boolean b3 = a>b && c++>2;
    System.out.println(b3); //false
    System.out.println(c);  //5,发生短路了
    
    //演示||的短路
    boolean b4 = a<b || c++>2;
    System.out.println(b4); //true
    System.out.println(c);  //5,发生短路了
    
    
    1. 运算符的练习:赋值
    • 声明一个整型变量,演示扩展赋值+=、-=、*=、/=、%=的效果
    • 声明short型变量s,演示简单赋值运算的自增10,演示扩展赋值运算的自增10

    参考代码:

    int a = 5;
    a += 10; //相当于a=(int)(a+10)
    System.out.println(a); //15
    a *= 2; //相当于a=(int)(a*2)
    System.out.println(a); //30
    a /= 6; //相当于a=(int)(a/6)
    System.out.println(a); //5
    
    short s = 5;
    //s = s+10; //编译错误,需强转,改为: s=(short)(s+10);
    s += 10; //相当于s=(short)(s+10)
    
    1. 运算符的练习:字符串连接
    • 声明整型变量age和字符串型变量name,输出字符串连接的结果
    • 输出几个数据的拼接,演示字符串连接的同化作用

    参考代码:

    //演示字符串连接
    int age = 38;
    System.out.println("age="); //age=
    System.out.println(age);    //38
    System.out.println("age="+age); //age=38
    System.out.println("我的年龄是"+age); //我的年龄是38
    System.out.println("我今年"+age+"岁了"); //我今年38岁了
    
    String name = "WKJ";
    System.out.println("name="+name); //name=WKJ
    System.out.println("大家好,我叫"+name); //大家好,我叫WKJ
    System.out.println("大家好,我叫"+name+",今年"+age+"岁了"); //大家好,我叫WKJ,今年38岁了
    
    //演示同化作用
    System.out.println(10+20+""+30); //3030---------String
    System.out.println(""+10+20+30); //102030-------String
    System.out.println(10+20+30+""); //60-----------String
    
    1. 运算符的练习:条件/三目
    • 声明并初始化整型变量,使用条件运算符实现:若>0则给flag赋值为1,否则赋值为0
    • 声明两个整型变量,使用条件运算符实现:求这两个变量的最大值

    参考代码:

    int num = 5;
    int flag = num>0?1:-1;
    System.out.println(flag); //1
    
    int a=8,b=5;
    int max = a>b?a:b;
    System.out.println("max="+max);
    
    1. 分支结构的练习:if
    • 偶数的判断:声明并初始化一个整型变量,判断该数是否是偶数
    • 满500打8折:声明并初始化一个浮点型价格,若满500则打8折

    参考代码:

    //1)偶数的判断:
    int num = 6; //带数(6,5)
    if(num%2==0){
        System.out.println(num+"是偶数");
    }
    System.out.println("继续执行...");
    
    //2)满500打8折
    //带数(600.0,300.0)
    double price = 300.0; //消费金额
    if(price>=500){ //满500
        price*=0.8; //打8折
    }
    System.out.println("最终结算金额为:"+price);
    
    1. 分支结构的练习:if…else
    • 偶数、奇数的判断:声明并初始化一个整型变量,判断该数是偶数还是奇数
    • 满500打8折:声明并初始化一个浮点型价格,若满500则打8折,否则打9折

    参考代码:

    //if..else结构的演示
    public class IfElseDemo {
        public static void main(String[] args) {
            //1)偶数、奇数的判断:
            int num = 5; //带数(6,5)
            if(num%2==0){
                System.out.println(num+"是偶数");
            }else{
                System.out.println(num+"是奇数");
            }
            System.out.println("继续执行...");
    
            //2)满500打8折,不满500打9折:
            double price = 300.0; //带数(600.0,300.0)
            if(price>=500){ //满500,打8折
                price*=0.8;
            }else{ //不满500,打9折
                price*=0.9;
            }
            System.out.println("最终结算金额为:"+price);
        }
    }
    
    1. 声明两个整型变量a和b并分别赋值,找到a和b中的最大值,并输出。用两种方式实现:条件运算符、if…else分支结构

    参考代码:

    package test;
    public class Day03 {
        public static void main(String[] args) {
    		/*
            int a=8,b=5;
            int max = a>b?a:b;
            System.out.println("max="+max);
            */
            
            int a=8,b=5;
            int max;
            if(a>b){
                max = a;
            }else{
                max = b;
            }
            System.out.println("max="+max);
        }
    }
    
    1. 声明一个整型变量year并存储年份,判断其是平年还是闰年,若是闰年则输出"某某某年是闰年",否则输出"某某某年是平年"。

    参考代码:

    package test;
    public class Day03 {
        public static void main(String[] args) {
    		/*
              闰年的判断公式:
              1)4年一闰,百年不闰,就是:能被4整除,并且,不能被100整除
                或者
              2)400年再闰,就是:能被400整除
             */
            int year = 2000; //年份  //带数(2021,2020,2000)
            if((year%4==0 && year%100!=0) || year%400==0){
                System.out.println(year+"是闰年");
            }else{
                System.out.println(year+"是平年");
            }
        }
    }
    
    1. ScoreLevel成绩等级判断:接收用户输入的成绩,判断成绩的等级ABCD

    参考代码:

    package day04;
    import java.util.Scanner;
    //成绩等级判断
    public class ScoreLevel {
        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            System.out.println("请输入成绩:");
            double score = scan.nextDouble();
    
            //带数(888,-45,95,85,65,45)
            if(score<0 || score>100){
                System.out.println("成绩不合法");
            }else if(score>=90){ //合法
                System.out.println("A-优秀");
            }else if(score>=80){
                System.out.println("B-良好");
            }else if(score>=60){
                System.out.println("C-中等");
            }else{
                System.out.println("D-不及格");
            }
    
        }
    }
    
    1. CommandBySwitch命令解析程序:接收用户输入的命令,依据命令做不同的操作

    参考代码:

    package day04;
    import java.util.Scanner;
    //命令解析程序
    public class CommandBySwitch {
        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            System.out.println("请选择功能: 1.取款  2.存款  3.查询余额  0.退卡");
            int command = scan.nextInt();
    
            switch(command){
                case 1:
                    System.out.println("取款操作...");
                    break;
                case 2:
                    System.out.println("存款操作...");
                    break;
                case 3:
                    System.out.println("查询余额操作...");
                    break;
                case 0:
                    System.out.println("退出成功");
                    break;
                default:
                    System.out.println("输入错误");
            }
        }
    }
    
    1. Guessing猜数字之while版:随机生成一个数,由用户来猜,猜不对则反复猜,并给出大小提示,猜对的则结束,用while来实现。

    参考代码:

    package day04;
    import java.util.Scanner;
    //猜数字小游戏
    public class Guessing {
        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            int num = (int)(Math.random()*1000+1); //1到1000之内
            System.out.println(num); //作弊
            
            //300(大),200(小),250(对)
            System.out.println("猜吧!");
            int guess = scan.nextInt(); //1.
            while(guess!=num){ //2.
                if(guess>num){
                    System.out.println("太大了");
                }else{
                    System.out.println("太小了");
                }
                System.out.println("猜吧!");
                guess = scan.nextInt(); //3.
            }
            System.out.println("恭喜你猜对了!");
        }
    }
    
    1. Guessing猜数字之do…while版:随机生成一个数,由用户来猜,猜不对则反复猜,并给出大小提示,猜对的则结束,用do…while来实现。

    参考代码:

    package day04;
    import java.util.Scanner;
    //猜数字小游戏
    public class Guessing {
        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            int num = (int)(Math.random()*1000+1); //1到1000之内
            System.out.println(num); //作弊
    
            //假设num=250
            //300(大),200(小),250(对)
            int guess;
            do{
                System.out.println("猜吧!");
                guess = scan.nextInt(); //1+3
                if(guess>num){
                    System.out.println("太大了");
                }else if(guess<num){
                    System.out.println("太小了");
                }else{
                    System.out.println("恭喜你猜对了");
                }
            }while(guess!=num); //2
        }
    }
    
    1. 接收用户输入的一个整数num,判断它的正负零值,正数则输出"+“,负数则输出”-“,0则输出"0”

    参考代码:

    package test;
    import java.util.Scanner;
    public class Day04 {
        public static void main(String[] args) {
    		Scanner scan = new Scanner(System.in);
            System.out.println("请输入一个整数:");
            int num = scan.nextInt();
    
            if(num>0){
                System.out.println("+");
            }else if(num<0){
                System.out.println("-");
            }else{
                System.out.println("0");
            }
        }
    }
    
    1. 接收用户输入的年份year和月份month,计算该年该月的天数,并输出

    参考代码:

    package test;
    import java.util.Scanner;
    public class Day04 {
        public static void main(String[] args) {
    		Scanner scan = new Scanner(System.in);
            System.out.println("请输入年份:");
            int year = scan.nextInt();
            System.out.println("请输入月份:");
            int month = scan.nextInt();
            int days = 0; //天数
            switch(month){
                case 1:
                case 3:
                case 5:
                case 7:
                case 8:
                case 10:
                case 12:
                    days = 31;
                    break;
                case 4:
                case 6:
                case 9:
                case 11:
                    days = 30;
                    break;
                case 2:
                    if((year%4==0 && year%100!=0) || year%400==0){
                        days = 29;
                    }else{
                        days = 28;
                    }
            }
            System.out.println(year+"年的"+month+"月共"+days+"天");
        }
    }
    
    1. 利用循环语句while计算数字1到100的和,并输出

    参考代码:

    package test;
    public class Day04 {
        public static void main(String[] args) {
    		int sum = 0; //和
            int i = 1;
            while(i<=100){
                sum+=i;
                i++;
            }
            System.out.println("sum="+sum);
        }
    }
    
    1. Addition随机加法运算器:由系统随机出10道加法题,而后由用户来答题,答题后输出"答对了"或"答错了",答对1题得10分,答错1题不扣分,最后输出总分数。

    参考代码:

    package day05;
    import java.util.Scanner;
    //随机加法运算器
    public class Addition {
        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            int score = 0; //得分
            for(int i=1;i<=10;i++){ //10次    (1)25+36=?
                int a = (int)(Math.random()*100); //加数a(0到99的随机数)
                int b = (int)(Math.random()*100); //加数b(0到99的随机数)
                int result = a+b; //存正确答案
                System.out.println("("+i+")"+a+"+"+b+"=?"); //1)出题
                System.out.println("算吧!");
                int answer = scan.nextInt(); //2)答题
                if(answer==-1){ //3)判题
                    break;
                }
                if(answer==result){
                    System.out.println("答对了");
                    score+=10; //答对1题加10分
                }else{
                    System.out.println("答错了");
                }
            }
            System.out.println("总分为:"+score);
        }
    }
    
    1. MultiType九九乘法表:输出九九乘法表

    参考代码:

    package day05;
    //九九乘法表
    public class MultiTable {
        public static void main(String[] args) {
            for(int num=1;num<=9;num++){ //控制行
                for(int i=1;i<=num;i++){ //控制列
                    System.out.print(i+"*"+num+"="+i*num+"\t");
                }
                System.out.println(); //换行
            }
        }
    }
    
    1. 数组小代码练习:声明
    • 定义至少两个数组,设计包含一些元素

    参考代码:

    //声明整型数组arr,包含10个元素,每个元素都是int型,默认值为0
    int[] arr = new int[10];
    
    1. 数组小代码练习:初始化
    • 定义至少三个数组,演示三种元素初始化方式

    参考代码:

    //2)数组的初始化:--初始化的是数组中的数据
    int[] arr1 = new int[3]; //0,0,0
    int[] arr2 = {2,5,8}; //2,5,8
    int[] arr3 = new int[]{2,5,8}; //2,5,8
    int[] arr4;
    //arr4 = {2,5,8}; //编译错误,此方式只能声明同时初始化
    arr4 = new int[]{2,5,8}; //正确
    
    1. 数组小代码练习:访问
    • 定义数组,输出数组的长度
    • 定义数组并分别给每个元素赋值,输出最后一个元素的值
    • 编写代码演示数组操作常见的异常----数组下标越界

    参考代码:

    //3)数组的访问:--访问的是数组中的数据
    int[] arr = new int[3];
    System.out.println(arr.length); //3,输出arr的长度
    arr[0] = 100; //给arr中第1个元素赋值为100
    arr[1] = 200; //给arr中第2个元素赋值为200
    arr[2] = 300; //给arr中第3个元素赋值为300
    //arr[3] = 400; //运行时发生ArrayIndexOutOfBoundsException数组下标越界异常
    System.out.println(arr[arr.length-1]); //输出最后一个元素的值
    
    1. 数组小代码练习:遍历
    • 定义数组,包含10个元素,遍历数组,给每个元素赋值为0到99之间的随机数,输出每个元素的值

    参考代码:

    int[] arr = new int[10];
    for(int i=0;i<arr.length;i++){ //遍历arr数组
        arr[i] = (int)(Math.random()*100); //给每个元素赋值为0到99的随机数
        System.out.println(arr[i]); //输出每个元素的值
    }
    
    1. 利用for循环计算:求数字1到100之内,所有偶数的和,并输出

    参考代码:

    package test;
    public class Day05 {
        public static void main(String[] args) {
    		int sum = 0;
            for(int i=2;i<=100;i+=2){
                sum+=i;
            }
            System.out.println("sum="+sum);
        }
    }
    
    1. 利用for循环计算:求8的阶乘,并输出

    参考代码:

    package test;
    public class Day05 {
        public static void main(String[] args) {
    		int num = 1; //阶乘
            for(int i=1;i<=8;i++){
                num*=i;
            }
            System.out.println("num="+num);
        }
    }
    
    1. 利用for循环计算:打印字符*组成的等腰三角形,输出结果如下所示:
         *
        ***
       *****
      *******
     *********
    ***********
    

    参考代码:

    package test;
    public class Day05 {
        public static void main(String[] args) {
    		for(int i=1;i<=6;i++){
                for(int j=1;j<=6-i;j++){ //空格
                    System.out.print(" ");
                }
                for(int k=1;k<=2*i-1;k++){
                    System.out.print("*");
                }
                System.out.println();
            }
        }
    }
    
    1. MaxOfArray求数组元素最大值并放在最后一个元素的下一个位置:声明整型数组并填充随机数据,找到最大值,将数组扩容并将最大值放末尾

    参考代码:

    package day06;
    import java.util.Arrays;
    //求数组元素的最大值,并将其放在最后一个元素的下一个位置
    public class MaxOfArray {
        public static void main(String[] args) {
            int[] arr = new int[10];
            for(int i=0;i<arr.length;i++){
                arr[i] = (int)(Math.random()*100);
                System.out.println(arr[i]);
            }
    
            int max = arr[0]; //假设第1个元素为最大值
            for(int i=1;i<arr.length;i++){ //遍历剩余元素
                if(arr[i]>max){   //若剩余元素大于max
                    max = arr[i]; //则将max修改为较大的
                }
            }
            System.out.println("最大值为:"+max);
    
            arr = Arrays.copyOf(arr,arr.length+1); //扩容
            arr[arr.length-1] = max; //将最大值max放到最后一个元素上
            for(int i=0;i<arr.length;i++){
                System.out.println(arr[i]);
            }
        }
    }
    
    1. 数组排序的练习:声明整型数组并填充数据,排序,输出排序后数据,倒序输出数据

    参考代码:

    package day06;
    import java.util.Arrays;
    //数组的演示
    public class ArrayDemo {
        public static void main(String[] args) {
            //8)数组的排序:
            int[] arr = new int[10];
            for(int i=0;i<arr.length;i++){
                arr[i] = (int)(Math.random()*100);
                System.out.println(arr[i]);
            }
    
            Arrays.sort(arr); //对arr进行升序排列
    
            System.out.println("数组排序后的数据:");
            for(int i=0;i<arr.length;i++){
                System.out.println(arr[i]);
            }
            
            System.out.println("倒序输出:");
            for(int i=arr.length-1;i>=0;i--){
                System.out.println(arr[i]);
            }
        }
    }
    
    1. 方法的练习:参数
    • 定义say()无参无返回值方法,调用测试
    • 定义sayHi()有一个参无返回值方法,调用测试
    • 定义sayHello()有两个参无返回值的方法,调用测试

    参考代码:

    package day06;
    //方法的演示
    public class MethodDemo {
        public static void main(String[] args) {
            say();
            sayHi("zhangsan"); //String name="zhangsan"
            sayHello("zhangsan",25); //String name="zhangsan",int age=25
        }
        
        //无参无返回值
        public static void say(){
            System.out.println("大家好,我叫WKJ,今年38岁了");
        }
        
        //有参无返回值
        public static void sayHi(String name){
            System.out.println("大家好,我叫"+name+",今年38岁了");
        }
        
        //有参无返回值
        public static void sayHello(String name,int age){
            if(age>=35){ //在某种特定条件下,提前结束方法
                return; //结束方法的执行
            }
            System.out.println("大家好,我叫"+name+",今年"+age+"岁了");
        }
    }
    
    1. 方法的练习:返回值
    • 定义getNum()无参有返回值方法,演示return的用法,调用测试
    • 定义plus()两个参有返回值方法,调用测试
    • 定义testArray()用于生成整型数组填充随机数并返回数组,调用测试

    参考代码:

    package day06;
    //方法的演示
    public class MethodDemo {
        public static void main(String[] args) {
            double a = getNum(); //getNum()值就是return后那个数
    		System.out.println(a); //8.88,模拟对返回值的后续操作
    
            int b = plus(5,6);
            System.out.println(b); //11,模拟对返回值的后续操作
            int m=5,n=6;
            int c = plus(m,n); //传递的是m和n里面的数
            System.out.println(c); //11,模拟对返回值的后续操作
    
            int[] d = testArray();
            System.out.println("长度为:"+d.length); //10,模拟对返回值的后续操作
            for(int i=0;i<d.length;i++){ //模拟对返回值的后续操作
                System.out.println(d[i]);
            }
        }
        
        //无参有返回值
        public static double getNum(){
            //return "abc"; //编译错误,返回值类型不匹配
            return 8.88; //1)结束方法的执行  2)返回结果给调用方
        }
        
        //有参有返回值
        public static int plus(int num1,int num2){
            int num = num1+num2;
            return num; //返回的是num里面的那个数
            //return num1+num2; //返回num1与num2的和
        }
        
        //无参有返回值
        public static int[] testArray(){
            int[] arr = new int[10];
            for(int i=0;i<arr.length;i++){
                arr[i] = (int)(Math.random()*100);
            }
            return arr;
        }
    }
    
    1. 定义一个方法generate()
    • 根据第一个参数生成指定长度的int数组;
    • 根据第二个范围参数随机生成0到指定范围的随机数,填充到数组元素中,并将该数组返回;
    • 测试数组内容。

    参考代码:

    package test;
    public class Day06 {
        public static void main(String[] args) {
    		int[] arr = generate(5,20);
            for(int i=0;i<arr.length;i++){
                System.out.println(arr[i]);
            }
        }
        //生成随机数组方法
        public static int[] generate(int len,int max){
            int[] arr = new int[len];
            for(int i=0;i<arr.length;i++){
                arr[i] = (int)(Math.random()*(max+1));
            }
            return arr;
        }
    }
    
    展开全文
  • Java基础练习题.pdf

    2021-10-03 23:54:36
    Java基础练习题.pdf
  • JAVA基础练习题.doc

    2021-09-30 23:02:30
    JAVA基础练习题.doc
  • 适合刚刚学习到面向对象三大特征的同学来巩固对知识的理解
  • java练习题java练习题java练习题(重要的事情说三遍--->不是,为了凑字数 -_-!! )
  • java基础练习题及答案.docx
  • Java是一门面向对象编程语言,不仅吸收了C++语言的各种优点,还摒弃了C++里难以理解的多继承、指针等概念,因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表,极好地实现了面向...
  • java基础练习题及答案.pdf
  • Java基础练习题-附答案.doc
  • ----------------学资学习网--------------- Java 附答案基础练习题 一简单Java程序调试 1以下哪个是Java应用程序main方法的有效定义? A. public static void main; B. public static void main( String args ; C. ...
  • Java基础练习题 附答案 一简单Java程序调试 以下哪个是Java应用程序main方法的有效定义 public static void mai n; public static void main( Stri ng args ; public static void main( String args[]; public ...
  • java基础练习题与答案.doc
  • JAVA 基础编程练习题 程序 1 /* 机选双色球 {"01, "02, "03, "04"05"06"07"08"09"10,~33} {false,true,false,false}*/ import java.util; class Demo07 { public static void main(String[] args) { String[] red...
  • java基础习题

    2018-09-13 11:39:31
    java基础课程的学习习题,配合黑马教程做课后巩固较佳。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 63,024
精华内容 25,209
关键字:

java基础练习题