如果您对java课java方法动手动脑感兴趣，那么本文将是一篇不错的选择，我们将为您详在本文中，您将会了解到关于java课java方法动手动脑的详细内容，我们还将为您解答java动作的相关问题，并且为
如果您对java课java方法动手动脑感兴趣，那么本文将是一篇不错的选择，我们将为您详在本文中，您将会了解到关于java课java方法动手动脑的详细内容，我们还将为您解答java动作的相关问题，并且为您提供关于10.18号java课后动手动脑、11.8java课后动手动脑、2019.10.14java动手动脑、JAVA 之类的动手动脑的有价值信息。
本文目录一览：
java课java方法动手动脑（java动作）
动手动脑：
import java.util.Scanner;
public class Random {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int n;
System.out.println("输入随机数个数");
n=input.nextInt();
int seed=1;
int c=0;
int num=0;
for(int i=0;i<n;i++){
seed=(7^5*seed+c)%(2^100);
num++;
System.out.print(seed+" ");
if(num%10==0) {
System.out.println();
}
}
}
}
课后验证1：CalculateN,java
import java.math.BigInteger;
import java.util.Scanner;
public class CalculateN {
/**
* @param args
*/
public static void main(String[] args) {
System.out.print("请输入N：");
Scanner scanner=new Scanner(System.in);
int number=scanner.nextInt();
System.out.println(number+"!="+calculateN2(number));
}
public static long calculateN(int n) {
if(n==1 || n==0){
return 1;
}
return n*calculateN(n-1);
}
public static BigInteger calculateN2(int n) {
if(n==1 || n==0){
return BigInteger.valueOf(1);
}
return BigInteger.valueOf(n).multiply(calculateN2((n-1)));
}
}
课后测试2：CompareFloatNumber.java
public class CompareFloatNumber {
/**
* @param args
*/
public static void main(String[] args) {
//compare();
compare2();
}
private static void compare() {
double i = 0.0001;
double j = 0.00010000000000000001;
System.out.println(i==j); //输出：true
}
private static void compare2() {
double i = 0.0001;
double j = 0.00010000000000000001;
if(Math.abs(i-j)<1e-10){
System.out.println("true");
}
else
{
System.out.println("false");
}
}
}
课后测试3：MethodOverload.java
public class MethodOverload {
public static void main(String[] args) {
System.out.println("The square of integer 7 is " + square(7));
System.out.println("\nThe square of double 7.5 is " + square(7.5));
}
public static int square(int x) {
return x * x;
}
public static double square(double y) {
return y * y;
}
}
课后测试4：RandomInt.java
import javax.swing.JOptionPane;
public class RandomInt {
public static void main( String args[] )
{
int value;
String output = "";
for ( int i = 1; i <= 20; i++ ) {
value = 1 + (int) ( Math.random() * 6 );
output += value + " ";
if ( i % 5 == 0 )
output += "\n";
}
JOptionPane.showMessageDialog( null, output,
"20 Random Numbers from 1 to 6",
JOptionPane.INFORMATION_MESSAGE );
System.exit( 0 );
}
}
课后测试5：RollDie.java
import javax.swing.*;
public class RollDie {
public static void main( String args[] )
{
int frequency1 = 0, frequency2 = 0,
frequency3 = 0, frequency4 = 0,
frequency5 = 0, frequency6 = 0, face;
// summarize results
for ( int roll = 1; roll <= 6000; roll++ ) {
face = 1 + (int) ( Math.random() * 6 );
switch ( face ) {
case 1:
++frequency1;
break;
case 2:
++frequency2;
break;
case 3:
++frequency3;
break;
case 4:
++frequency4;
break;
case 5:
++frequency5;
break;
case 6:
++frequency6;
break;
}
}
JTextArea outputArea = new JTextArea( 7, 10 );
outputArea.setText(
"Face\tFrequency" +
"\n1\t" + frequency1 +
"\n2\t" + frequency2 +
"\n3\t" + frequency3 +
"\n4\t" + frequency4 +
"\n5\t" + frequency5 +
"\n6\t" + frequency6 );
JOptionPane.showMessageDialog( null, outputArea,
"Rolling a Die 6000 Times",
JOptionPane.INFORMATION_MESSAGE );
System.exit( 0 );
}
}
课后测试6：SquareInt.java
public class SquareInt {
public static void main(String[] args) {
int result;
for (int x = 1; x <= 10; x++) {
result = square(x);
// Math库中也提供了求平方数的方法
// result=(int)Math.pow(x,2);
System.out.println("The square of " + x + " is " + result + "\n");
}
}
// 自定义求平方数的静态方法
public static int square(int y) {
return y * y;
}
}
课后测试7：TestRandom.java
import java.util.*;
public class TestRandom
{
public static void main(String[] args)
{
Random rand = new Random();
System.out.println("rand.nextBoolean()：" + rand.nextBoolean());
byte[] buffer = new byte[16];
rand.nextBytes(buffer);
System.out.println(Arrays.toString(buffer));
//生成0.0~1.0之间的伪随机double数
System.out.println("rand.nextDouble()：" + rand.nextDouble());
//生成0.0~1.0之间的伪随机float数
System.out.println("rand.nextFloat()：" + rand.nextFloat());
//生成平均值是 0.0，标准差是 1.0的伪高斯数
System.out.println("rand.nextGaussian()：" + rand.nextGaussian());
//生成一个处于long整数取值范围的伪随机整数
System.out.println("rand.nextInt()：" + rand.nextInt());
//生成0~26之间的伪随机整数
System.out.println("rand.nextInt(26)：" + rand.nextInt(26));
//生成一个处于long整数取值范围的伪随机整数
System.out.println("rand.nextLong()：" + rand.nextLong());
}
}
课后测试8：TestSeed.java
import java.util.Random;
public class TestSeed
{
public static void main(String[] args)
{
Random r1 = new Random(50);
System.out.println("第一个种子为50的Random对象");
System.out.println("r1.nextBoolean():\t" + r1.nextBoolean());
System.out.println("r1.nextInt():\t\t" + r1.nextInt());
System.out.println("r1.nextDouble():\t" + r1.nextDouble());
System.out.println("r1.nextGaussian():\t" + r1.nextGaussian());
System.out.println("---------------------------");
Random r2 = new Random(50);
System.out.println("第二个种子为50的Random对象");
System.out.println("r2.nextBoolean():\t" + r2.nextBoolean());
System.out.println("r2.nextInt():\t\t" + r2.nextInt());
System.out.println("r2.nextDouble():\t" + r2.nextDouble());
System.out.println("r2.nextGaussian():\t" + r2.nextGaussian());
System.out.println("---------------------------");
Random r3 = new Random(100);
System.out.println("种子为100的Random对象");
System.out.println("r3.nextBoolean():\t" + r3.nextBoolean());
System.out.println("r3.nextInt():\t\t" + r3.nextInt());
System.out.println("r3.nextDouble():\t" + r3.nextDouble());
System.out.println("r3.nextGaussian():\t" + r3.nextGaussian());
Random r4 = new Random(System.currentTimeMillis());
System.out.println("以当前时间为种子的Random对象");
System.out.println("r3.nextBoolean():\t" + r4.nextBoolean());
System.out.println("r3.nextInt():\t\t" + r4.nextInt());
System.out.println("r3.nextDouble():\t" + r4.nextDouble());
System.out.println("r3.nextGaussian():\t" + r4.nextGaussian());
}
}
课后测试9：VariableArgumentsTest.java
import java.awt.*;
import java.awt.event.*;
import java.util.*;
public class VariableArgumentsTest{
public static double max(double...values)
{
double largest=Double.MIN_VALUE;
for (double v:values)
if(v>largest) largest=v;
return largest;
}
public static void main(String args[]) {
System.out.println("Max:"+max(1,11,300,2,3));
}
}
10.18号java课后动手动脑
问题一结论：类如果提供了一个自定义的构造方法，将导致系统不再提供默认构造方法。
问题二结论：(1)程序运行的结果是100和300，field=200为类的初始化块，可以在类中使用“{”和“}”将语句包围起来，直接将其作为类的成员。类的这种“没有名字”的“成员”.多用于初始化类的字段。
(2)public int field=100; 在定义时进行初始化,此时field = 100。
(3)System.out.println(obj.field); 输出field的值100。
(4)obj=new InitializeBlockClass(300);System.out.println(obj.field);利用构造方法进行初始化,field的值初始化为300,输出300。
规律：
（1）执行类成员定义时指定的默认值或类的初始化块，到底执行哪一个要看哪一个“排在前面”。
（2）执行类的构造函数。
（3）类的初始化块不接收任何的参数，而且只要一创建类的对象，它们就会被执行。因此，适合于封装那些“对象创建时必须执行的代码”。
问题三结论：代码为
class Root
{
static{
System.out.println("Root的静态初始化块");
}
{
System.out.println("Root的普通初始化块");
}
public Root()
{
System.out.println("Root的无参数的构造器");
}
}
class Mid extends Root
{
static{
System.out.println("Mid的静态初始化块");
}
{
System.out.println("Mid的普通初始化块");
}
public Mid()
{
System.out.println("Mid的无参数的构造器");
}
public Mid(String msg)
{
//通过this调用同一类中重载的构造器
this();
System.out.println("Mid的带参数构造器，其参数值：" + msg);
}
}
class Leaf extends Mid
{
static{
System.out.println("Leaf的静态初始化块");
}
{
System.out.println("Leaf的普通初始化块");
}
public Leaf()
{
//通过super调用父类中有一个字符串参数的构造器
super("Java初始化顺序演示");
System.out.println("执行Leaf的构造器");
}
}
public class TestStaticInitializeBlock
{
public static void main(String[] args)
{
new Leaf();
}
}运行结果如下：
结论：静态初始化块只会在第一次装入系统的时候运行，当再次实例化的时候就不需要再执行了，因为已经存在了。创建子类型的对象时，也会导致父类型的静态初始化块的执行。
11.8java课后动手动脑
package 动手动脑;
import javax.swing.*;
class AboutException {
public static void main(String[] a)
{
int i=1, j=0, k;
k=i/j;
try
{
k = i/j; // Causes division-by-zero exception
//throw new Exception("Hello.Exception!");
}
catch ( ArithmeticException e)
{
System.out.println("被0除. "+ e.getMessage());
}
catch (Exception e)
{
if (e instanceof ArithmeticException)
System.out.println("被0除");
else
{
System.out.println(e.getMessage());
}
}
finally
{
JOptionPane.showConfirmDialog(null,"OK");
}
}
}Java中实现异常处理的基础知识：
1.Java 中所有可捕获的异常都派生自 Exception 类。把可能会发生错误的代码放进try语句块中。 当程序检测到出现了一个错误时会抛出一个异常对象。异常处理代码会捕获并处理这个错误。 catch语句块中的代码用于处理错误。 当异常发生时，程序控制流程由try语句块跳转到catch语句块。 不管是否有异常发生，finally语句块中的语句始终保证被执行。 如果没有提供合适的异常处理代码，JVM将会结束掉整个应用程序。
动手动脑二：
package 动手动脑;
public class CatchWho {
public static void main(String[] args) {
try {
try {
throw new ArrayIndexofBoundsException();
}
catch(ArrayIndexofBoundsException e) {
System.out.println("ArrayIndexOutofBoundsException"+"/内层try-catch");
}
throw new Arithmetiception();
}
catch(Arithmetiception e) {
System.out.println("发生Arithmetiception");
}
catch(ArrayIndexOutofBoundsException e) {
System.out.println("ArrayIndexOutofBoundsException"+"/内层try-catch");
}
}
}结果：
动手动脑三：
package 动手动脑;
public class CatchWho2 {
public static void main(String[] args) {
try {
try {
throw new ArrayIndexofBoundsException();
}
catch(ArrayIndexofBoundsException e) {
System.out.println("ArrayIndexOutofBoundsException"+"/内层try-catch");
}
throw new Arithmetiception();
}
catch(Arithmetiception e) {
System.out.println("发生Arithmetiception");
}
catch(ArrayIndexOutofBoundsException e) {
System.out.println("ArrayIndexOutofBoundsException"+"/内层try-catch");
}
}
}结果：
动手动脑四：
package 动手动脑;
public class EmbededFinally {
public static void main(String args[]) {
int result;
try {
System.out.println("in Level 1");
try {
System.out.println("in Level 2");
// result=100/0; //Level 2
try {
System.out.println("in Level 3");
result=100/0; //Level 3
}
catch (Exception e) {
System.out.println("Level 3:" + e.getClass().toString());
}
finally {
System.out.println("In Level 3 finally");
}
// result=100/0; //Level 2
}
catch (Exception e) {
System.out.println("Level 2:" + e.getClass().toString());
}
finally {
System.out.println("In Level 2 finally");
}
// result = 100 / 0; //level 1
}
catch (Exception e) {
System.out.println("Level 1:" + e.getClass().toString());
}
finally {
System.out.println("In Level 1 finally");
}
}
}结果：
总结：
finally功用：1、资源泄露：当一个资源不再被某应用程序使用，但此程序并未向系统声明不再使用此资源时发生这种情况 finally语句块主要用于解决资源泄露问题，它位于catch语句块之后，JVM保证它们一定执行。 注意：finally语句块中也可能发生异常，如果这种情况发生，先前的异常被放弃。
动手动脑五：
package 动手动脑;
public class SystemExitAndFinally {
public static void main(String[] args)
{
try{
System.out.println("in main");
throw new Exception("Exception is thrown in main");
//System.exit(0);
}
catch(Exception e)
{
System.out.println(e.getMessage());
System.exit(0);
}
finally
{
System.out.println("in finally");
}
}
}结果：
总结：finally语句块不一定会执行，如果finally块中的代码过多会导致字节码条数”膨胀”，因为finally中的字节码会被”复制”到try块和所有的catch块中。
2019.10.14java动手动脑
这次动手动脑，我学到了多个构造函数的顺序和相互调用，
比如这个程序运行结果如下，由此我们知道，如果类里面自己定义了一个构造函数；系统将不会默认给出构造函数供主函数调用。
1 package hello;
2
3 public class Hello {
4 public int value=200;
5 {
6 value =100;
7 }
8
9 public Hello() {
10 this.value = 300;
11 }
12
13 public static void main(String[] args) {
14 Hello hello=new Hello();
15 System.out.println("初始化值为="+hello.value);
16 }
17 }
这是个初始化调用的问题，由运行结果我们可知道，系统会先调用构造函数，初始化数据。
3、
1 class Root
2 {
3 static{
4 System.out.println("Root的静态初始化块");
5 }
6
7 {
8 System.out.println("Root的普通初始化块");
9 }
10 public Root()
11 {
12 System.out.println("Root的无参数的构造器");
13 }
14 }
15 class Mid extends Root
16 {
17 static{
18 System.out.println("Mid的静态初始化块");
19 }
20 {
21 System.out.println("Mid的普通初始化块");
22 }
23 public Mid()
24 {
25 System.out.println("Mid的无参数的构造器");
26 }
27 public Mid(String msg)
28 {
29 //通过this调用同一类中重载的构造器
30 this();
31 System.out.println("Mid的带参数构造器，其参数值：" + msg);
32 }
33 }
34 class Leaf extends Mid
35 {
36 static{
37 System.out.println("Leaf的静态初始化块");
38 }
39
40 {
41 System.out.println("Leaf的普通初始化块");
42 }
43
44 public Leaf()
45 {
46 //通过super调用父类中有一个字符串参数的构造器
47 super("Java初始化顺序演示");
48 System.out.println("执行Leaf的构造器");
49 }
50
51 }
52
53 public class TestStaticInitializeBlock
54 {
55 public static void main(String[] args)
56 {
57 new Leaf();
58
59
60 }
61 }
编译顺序是，在构建子类对象时，先构建父类的对象，之后一次执行相应的静态语句块，然后依次执行相应的普通语句块和构造函数，当在子类中有super（）；时，分类的构造函数使用super（）；调用的父类构造函数。
JAVA 之类的动手动脑
1. 默认构造方法与自定义的构造方法的冲突
package com.xu;
class fool
{
int value;
fool(int nowvalue)
{
value=nowvalue;
}
}
public class hello {
public static void main(String[] args) {
// TODO Auto-generated method stub
fool f=new fool();
}
}可他为什么会报错呢？
原因是：假如不去自定义构造函数方法，java 编译器在编译时会自动提供一个没有参数的 “默认构造方法”，上述代码即可成立
然而，如果你自己定义了一个构造方法，将导致系统不再提供默认的构造方法，因此会报错，报错原因是你没有初始化的时候传入参数。
2.java 初始化的先后顺序
package com.xu;
public class hello {
hello()
{
System.out.println("调用无参构造");
}
hello(int nowvalue)
{
this.value=nowvalue;
System.out.println("调用有参构造");
}
{
value=900;
System.out.println("999");
}
public int value=200;
public static void main(String[] args) {
// TODO Auto-generated method stub
hello h1=new hello();
System.out.println("无参构造的输出为："+h1.value);
hello h2=new hello(1000);
System.out.println("有参构造的输出为："+h2.value);
}
}输出为：
999
调用无参构造
无参构造的输出为：200
999
调用有参构造
有参构造的输出为：1000
在初始化块和数据的指定值之间的执行数序是：谁在前就先执行谁
对于构造函数在他们之后执行。
3. 静态初始化块的执行顺序
class Root
{
static{
System.out.println("Root的静态初始化块");
}
{
System.out.println("Root的普通初始化块");
}
public Root()
{
System.out.println("Root的无参数的构造器");
}
}
class Mid extends Root
{
static{
System.out.println("Mid的静态初始化块");
}
{
System.out.println("Mid的普通初始化块");
}
public Mid()
{
System.out.println("Mid的无参数的构造器");
}
public Mid(String msg)
{
//通过this调用同一类中重载的构造器
this();
System.out.println("Mid的带参数构造器，其参数值：" + msg);
}
}
class Leaf extends Mid
{
static{
System.out.println("Leaf的静态初始化块");
}
{
System.out.println("Leaf的普通初始化块");
}
public Leaf()
{
//通过super调用父类中有一个字符串参数的构造器
super("Java初始化顺序演示");
System.out.println("执行Leaf的构造器");
}
}
public class TestStaticInitializeBlock
{
public static void main(String[] args)
{
new Leaf();
}
}输出为：
Root 的静态初始化块
Mid 的静态初始化块
Leaf 的静态初始化块
Root 的普通初始化块
Root 的无参数的构造器
Mid 的普通初始化块
Mid 的无参数的构造器
Mid 的带参数构造器，其参数值：Java 初始化顺序演示
Leaf 的普通初始化块
执行 Leaf 的构造器
在构造子类对象时，会先构造父类对象，静态初始化块优先执行，其次是父类的非静态初始化块，父类的构造函数，然后是子类的非静态初始化块，子类的构造函数。
4. 在静态方法中访问非静态成员和方法
我们都知道在静态方法中不能直接访问非静态的成员及方法
那么，我们就真的不能吗？
当然也可以，我们可以在静态方法中实例化包含非静态方法的类的对象。这样通过对象就可以间接的访问非静态方法和数据
package com.xu;
public class hello {
public int value=0;
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
//静态方法中调用非静态的成员及方法
static void f()
{
hello s=new hello();
System.out.println(s.getValue());
int k=10;
s.setValue(k);
System.out.println(s.getValue());
}
public static void main(String[] args) {
// TODO Auto-generated method stub
f();
}
}输出：
0
10
5. 诡异的 Integer
public class StrangeIntegerBehavior
{
public static void main(String[] args)
{
Integer i1=100;
Integer j1=100;
System.out.println(i1==j1);
Integer i2=129;
Integer j2=129;
System.out.println(i2==j2);
}
}输出：
true
false
为什么第二个会是 false 呢？
java 在编译 Integer x = yyy ; 时，会翻译成为 Integer x = Integer.valueOf (yyy)。而 java API 中对 Integer 类型的 valueOf 的定义如下，对于 - 128 到 127 之间的数，会进行缓存，Integer i = 127 时，会将 127 进行缓存，下次再写 Integer j = 127 时，就会直接从缓存中取，就不会 new 了。如果超过 128 就会重新 new 一个新对象。
所以 i2 和 j2 都是重新 new 的对象，故他们的地址不同，输出为 false。
而 i1 和 j1 都是缓存过的，用的时候直接提取出来即可，因而他们的地址是一样的。
课后作业
1. 使用类的静态字段和构造函数，可以跟踪某个类所创建对象的个数。请写一个类，在任何时候都可向他查询生成多少个对象
package com.xu;
public class hello {
static int num=0;
hello()
{
num++;
System.out.println("已创建"+num+"个对象");
}
public static void main(String[] args) {
// TODO Auto-generated method stub
hello h1=new hello();
hello h2=new hello();
hello h3=new hello();
System.out.println("一共创建了"+num+"个对象");
}
}
输出：
已创建 1 个对象
已创建 2 个对象
已创建 3 个对象
一共创建了 3 个对象
关于java课java方法动手动脑和java动作的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于10.18号java课后动手动脑、11.8java课后动手动脑、2019.10.14java动手动脑、JAVA 之类的动手动脑等相关内容，可以在本站寻找。
本文标签：
