「java四题」java 题

本篇文章给大家谈谈java四题，以及java 题对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、Java中用数组做第四题
• 2、四道Java基础题，你能做对几道？
• 3、关于Java中的4道题目啊，求详细过程
• 4、JAVA编程题目，共四题，做其中一题就够了，
• 5、4道JAVA题目,一个20分!!!

Java中用数组做第四题

我这儿给两种方法吧

1、自己写一个排序，比如最简单的冒泡排序，就是我程序中注释掉的部分

2、调用Arrays类的现成方法sort，反向输出

import java.util.Arrays;

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

int arr[] = new int[5];

Scanner sc = new Scanner(System.in);

System.out.println("请依次输入数组的5个数：");

for(int i = 0; i 5; i++) {

arr[i] = sc.nextInt();

}

// bubbleSort(arr);

Arrays.sort(arr);//也可以注销此行，取消现有的注释

for(int i = 4; i = 0; i--) {

System.out.print(arr[i] + ", ");

}

System.out.println();

}

// public static void bubbleSort(int arr[]) {

// int n = arr.length, temp;

// for(int i = 0; i n - 1; i++) {

// for(int j = 0; j n - 1 - i; j++) {

// if(arr[j] arr[j+1]) {

// temp = arr[j];

// arr[j] = arr[j+1];

// arr[j+1] = temp;

// }

// }

// }

// }

}

四道Java基础题，你能做对几道？

符的使用

首先看一段比较有意思的代码

[java] view plaincopy

Integer a = 1000,b=1000;

Integer c = 100,d=100;    public void mRun(final String name){

    new Runnable() {

        public void run() {

            System.out.println(name);

        }

    };

}

System.out.println(a==b);

System.out.println(c==d);

如果这道题你能得出正确答案，并能了解其中的原理的话。说明你基础还可以。如果你的答案 是 true 和true的话，你的基础就有所欠缺了。

首先公布下答案， 运行代码，我们会得到 false true。我们知道==比较的是两个对象的引用，这里的abcd都是新建出来的对象，按理说都应该输入false才对。这就是这道题的有趣之处，无论是面试题还是论坛讨论区，这道题的出场率都很高。原理其实很简单，我们去看下Integer.java这个类就了然了。

[java] view plaincopy

public static Integer valueOf(int i) {

  return  i = 128 || i -128 ? new Integer(i) : SMALL_VALUES[i + 128];

}

/**

* A cache of instances used by {@link Integer#valueOf(int)} and auto-boxing

*/

private static final Integer[] SMALL_VALUES = new Integer[256];

static {

  for (int i = -128; i 128; i++) {

      SMALL_VALUES[i + 128] = new Integer(i);

  }

}

当我们声明一个Integer c = 100;的时候。此时会进行自动装箱操作，简单点说，也就是把基本数据类型转换成Integer对象，而转换成Integer对象正是调用的valueOf方法，可以看到，Integer中把-128-127 缓存了下来。官方解释是小的数字使用的频率比较高，所以为了优化性能，把这之间的数缓存了下来。这就是为什么这道题的答案回事false和ture了。当声明的Integer对象的值在-128-127之间的时候，引用的是同一个对象，所以结果是true。

2String

接着看代码

[java] view plaincopy

          String s1 = "abc";

String s2 = "abc";

String s3 = new String("abc");

System.out.println(s1 == s2);

System.out.println(s1 == s3);

大家又来猜一猜这道题的答案是什么？

按照==的语法来看， 首先s1、s2、s3是三个不同的对象，常理来说，输出都会是false。然而程序的运行结果确实true、false。第二个输出false可以理解，第一个输出true就又让人费解了。我们知道一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配，而堆内存中则存放new 出来的对象和数组。然而除此之外还有一块区域叫做常量池。像我们通常想String s1 = "abc"; 这样申明的字符串对象，其值就是存储在常量池中。当我们创建String s1 = "abc"这样一个对象之后，"abc"就存储到了常量池（也可叫做字符串池）中，当我们创建引用String s2 = "abc" 的时候，Java底层会优先在常量池中查找是否存在"abc"，如果存在则让s2指向这个值，不会重新创建，如果常量池中没有则创建并添加的池中。这就是为什么答案是true 和false的原因。

3final关键字

还是来看一段代码

[java] view plaincopy

public void mRun(final String name){

    new Runnable() {

        public void run() {

                        try {

                          Thread.sleep(1000);

                       } catch (InterruptedException e) {

                         // TODO Auto-generated catch block

                        e.printStackTrace();

                       }  

                       System.out.println(name);

        }

    }.start();

}

这种代码相信大家写过很多，当内部类访问局部变量的时候，需要在局部变量前加final修饰符，不然编译器就会报错。通常我们也是这么干的。好的，第二个问题来了，为什么要加final修饰符？相信大多数小伙伴都没有思考过这个问题，但凡使用的时候，直接加上就得了，从来没去深究过其中的原理。这对于一个优秀的程序员来说是不可取，我们不仅要知其然还要知其所以然。

现在我们来分析一下，为什么要加final关键字。首先内部类的生命周期是成员级别的，而局部变量的生命周期实在方法体之类。也就是说会出现这样一种情况，当mRun方法执行，new 的线程运行，新线程里面会睡一秒。主线程会继续执行，mRun执行完毕，name属性生命周期结束。1秒之后，Syetem.out.printh(name)执行。然而此时name已经寿终正寝，不在内存中了。Java就是为了杜绝这种错误，严格要求内部类中方位局部变量，必须使用final关键字修饰。局部变量被final修饰之后，此时会在内存中保有一份局部变得的复制品，当内部类访问的时候其实访问的是这个复制品。这就好像是把局部变量的生命周期变长了。说到底还是Java工程师提前把这个坑给我们填了，不然不知道又会有多少小伙伴会为了内部类局部变量而发愁了。

4Integer与int那些事

看下面代码

[java] view plaincopy

   Integer a = new Integer(1000);

int b = 1000;

Integer c = new Integer(10);

Integer d = new Integer(10);

System.out.println(a == b);

System.out.println(c == d);

这道题是继第一题的后续，如果这道题你能很快速的得出答案，那么恭喜你，==比较符你就算掌握的比较透彻了。

---------------我是华丽分割线-------------

正确答案： true 、false

看到这个答案很多小伙伴又会不解，先来说下第二个，按第一题来说Integer不是把-128-127缓存起来了吗？这不是应该是true嘛，但是你仔细看，这里的Integer是我们自己new出来的，并不是用的缓存，所以结果是false。 现在来看第一个为啥又是true了呢？ 首先这里的值为1000，肯定和我们所知的Integer缓存没有关系。既然和缓存没有关系，a是新new出来的对象，按理说输入应该是false才对。但是注意b这里是int类型。当int和Integer进行==比较的时候，Java会把Integer进行自动拆箱，也就是把Integer转成int类型，所以这里进行比较的是int类型的值，所以结果即为true。

学习Java的同学注意了！！！

学习过程中遇到什么问题或者想获取学习资源的话，欢迎加入Java学习交流群，群号码：232300090【长按复制】 我们一起学Java！

关于Java中的4道题目啊，求详细过程

4： 接口内部 属性： final 方法： 抽象，公共

final 要求 属性不可更改 cookie =new Cart("蛋黄派","达利园"); 这个修改了 cookie的地址，所以报错

8 ： A 主要玩的是上转型对象

记住一条就行： 子类对象可以赋值给父类对象， 父类对象 赋值给子类对象必须进行强转（只能保证语法正确，而不能保证结果，如果需要保证运行无异常，需要用到 instanceof 来判断）

B答案p1 p2没有关系，他们都是 A的子类，但他们本身无关系

C答案 p2 = p4 猛一看是正确的 ，仔细看下就错了 p4 他赋值给了 ClassA的引用，放入了 ClassC的父类， 对于编译器来说，他就认为 p4是 ClassA的对象。 将ClassA对象赋值给 ClassC p2 , 属于父类型转换为子类型，需要强制转换

D答案 语法应该是正确的，但是运行的时候应该会报类型转换异常

3 ： 答案是 什么都不输出

s+0 == "0" 任何对象和字符串相加 结果为字符串 例如 “1”+“2” = “12”

最后一个 B 但是这玩意我也不太清楚为什么。

我只知道 第一个结果 一定不会是0.4 有精度损失。

第二个结果我不太清楚

第三个结果 一定是0 30/300结果为0 ，将0转换为double 为 0.00 预计结果为0.1

第四个结果 为0.5 1/2+0.5 结果 为0.5 1/2 = 0 + 0.5 = 0.5 预计结果为 1

我不清楚为啥第二个结果是正确的，这貌似跟位运算有关！我只是排除来做的

JAVA编程题目，共四题，做其中一题就够了，

好了，你测试一下咯!

public interface ShapeArea {//定义ShapeArea接口

public double getArea();//double getArea( ):求一个形状的面积

public double getPerimeter();// Double getPerimeter( ):求一个形状的周长。

}

public class MyTriangle implements ShapeArea {

double x,y,z,s;//x,y,z ：double型，表示三角形的三条边

public MyTriangle(double x, double y, double z) {//方法:MyTriangle(double x, double y, double z):构造函数，给三条边和s赋值；

this.x = x;

this.y = y;

this.z = z;

this.s = (x+y+z)/2;

}

@Override

public double getArea() {

return Math.sqrt(this.s*(this.s-this.x)*(this.s-this.y)*(this.s-this.z));

}

@Override

public double getPerimeter() {

return (x+y+z);

}

@Override

public String toString() {

System.out.print("此三角形的面积和周长为：");

return this.getArea()+"、"+this.getPerimeter();

}

}

public class Test {//测试类

public static void main(String[] args) {

MyTriangle myTriangle = new MyTriangle(3, 4, 5);

System.out.println(myTriangle);

}

}

4道JAVA题目,一个20分!!!

package fromJune;

import java.util.Arrays;

import java.util.Scanner;

public class Baidu1 {

//从键盘输入10个数，将其倒序输出

public void demo1()

{

Scanner scan=new Scanner(System.in);

int[] arr=new int[10];

for(int i=0;iarr.length;i++)

{

arr[i]=scan.nextInt();

}

//输出

for(int i=9;i=0;i--)

{

System.out.print(arr[i]);

}

}

//从键盘输入10个数，将其按从大到小的顺序输出。

public void demo2()

{

Scanner scan=new Scanner(System.in);

int[] arr=new int[10];

//输入

for(int i=0;iarr.length;i++)

{

arr[i]=scan.nextInt();

}

//排序

Arrays.sort(arr);

//输出,因为上面的排序是从小到大的，所以输出反过来输出就是从大到小

for(int i=9;i=0;i--)

{

System.out.print(arr[i]);

}

}

//Fibonacci数列的第一项是0，第二项是1，以后各项都是前两项的和，编写程序求第N项的值

//返回值就是第N项的值

public int demo3(int n)

{

if(n==1||n==2)

return n;

return demo3(n-1)+demo3(n-2);

}

//编写程序输出：1+1/2！+1/3！+……+1/10！的结果

public void demo4()

{

int fenzi=0,fenmu=0;

for(int i=1;i=10;i++)

{

fenzi+=zhuanhua(i);

if(i==1)

fenmu=fenzi;

}

//此时的结果是fenzi/10!,还要做的就是简化

int gongyue=gongyue(fenzi, fenmu);

fenzi=fenzi/gongyue;

fenmu=fenmu/gongyue;

System.out.println(fenzi+"/"+fenmu);

}

//把分母全部转化成10！,然后分子都加起来

public int zhuanhua(int n)

{

int temp=1;

for(int i=n;i=10;i++)

temp=temp*i;

return temp;

}

//求两个数的最大公约数来简化结果

public int gongyue(int m,int n)

{

int r=m%n;

int temp=1;

while(r!=0)

{temp=r;

m=n;

n=r;

r=m%n;

}

return temp;

}

}

关于java四题和java 题的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。