java 练习

 

练习册

      --JAVA篇

 JAVA语言的入门（1）

一、上机作业练习：(星号为选做题)

 

1.      打印出所有的 " 水仙花数 "  。 ( 所谓 " 水仙花数 " 是指一个三位数，其各位数字立方和等于该数本身。例如： 153 是一个 " 水仙花数 " ，因为 153=1 的三次方＋ 5 的三次方＋ 3 的三次方。 )

法一：

public class sdf {

public static void main(String[] args) {

   int a=0;

   int b=0;

   int c=0;

   for(int i=100;i<999;i++)

   {

    a=i/100;

    b=i/10%10;

    c=i%10;

    if(i==(a*a*a+b*b*b+c*c*c))

     System.out.println(i);

   }

 

}

 

}

法二：

public class lo {

    public boolean aa(int s)

    {

           int a=0,b=0,c=0;

         a=s/100;

         b=s/10%10;

         c=s%10;

         if(a*a*a+b*b*b+c*c*c==s)

         {

              return true;

         }

          return false;

    }

      

    public static void main(String[] args) {

              // TODO Auto-generated method stub

          lo a=new lo();

    for(int i=100;i<1000;i++){

          if(a.aa(i)){

                 System.out.println(i);

          }

                

         

    }

    

       }

 

}

2 ． 打印出 1-100 之间 有多少个素数，并输出所有素数 。

 

public class ShuiXianHua {

 

 

public static void main(String[] args) {

 

   int a=0;

   int b=0;

   int c=0;

   for(int i=100;i<999;i++)

   {

    a=i/100;

    b=i/10%10;

    c=i%10;

    if(i==(a*a*a+b*b*b+c*c*c))

     System.out.println(i);

   }

 

}

 

}

3 、打印九九乘法表。* （选作）

public class dd {

    public static void main(String[] args) {

       // TODO Auto-generated method stub

       System.out.println(" 九九乘法表 ");

       for(int i=1;i<=9;i++) {

           for(int j=1;j<=i;j++) {

              System.out.print(j+"*"+i+"="+j*i+" ");

           }

           System.out.println(" ");

       }

 

    }

 

}

 

二、思考题：

 

1 、 java 中的数据类型有那些 ？

 

java 语言是一种严格的 “ 类型化 ” 语言。这意味着每个变量都必须有一个声明好的类型。 Java 语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。 Java 另外还提供大数字对象，但它不是 Java 的数据类型。
　　 1 、整数：
　　定义：没有小数部分的数字，负数是允许的。
　　种类： Java 提供四种整数类型：
　　 int 4 个字节 -2,147,483,648 到 2,147,483,647
　　 hort 2 个字节 -32,768 到 32,767
　　 long 8 个字节 -9,223,372,036,854,775,808L 到 9,223,372,036,854,775,807L
　　 byte 2 个字节 -128 到 127
　　 2 、浮点数：
　　定义：含有小数部分的数字。
　　分类： Java 提供两种浮点数：
　　 float 4 个字节 约 +—3.40282347E+38F （ 6~7 个有效的十进制数位）
　　 double 8 个字节 约 +-1.79769313486231570E+308 （ 15 个有效数位）
　　说明：
　　 1 ） float 类型的数值有个后缀： F ，如果没有后缀 F ，那么默认为 double 。 double 类型的数值也可以使用后缀 D 。
　　 2 ）当这些数字遇到取值范围错误时，会发生（上溢 Overflow ）；而在遇到象被零除时，会发生下溢（ Underflow ）。
　　 3 、字符类型：
　　定义：单引号用来表示 char 常量，
　　说明：
　　 1 ）双引号则表示一个字串，他是 Java 的一个对象，并不是数据类型。
　　 2 ） char 类型表示 Unicode 编码方案中的字符。
　　 Unicode 可同时包含 65536 个字符， ASCII/ANSI 只包含 255 个字符，实际上是 Unicode 的一个子集。 Unicode 字符通常用十六进制编码方案表示，范围在 '/u0000' 到 '/uFFFF' 之间。 /u0000 到 /u00FF 表示 ASCII/ANSI 字符。 /u 表示这是一个 Unicode 值。
　　 3 ）在 Java 中除了用这个 /u 的形式来表示字符外，还可以使用换码序列来表示特殊字符。
　　 /b 退格 /u0008
　　 /t Tab 制表 /u0009
　　 /n 换行 /u000a
　　 /r 硬回车 /u000d
　　 /" 双引号 /u0022
　　 /' 单引号 /u0027
　　 / 反斜杠 /u005c
　　 4 ）理论上在 Java 的应用程序和小应用程序中使用 Unicode 字符，但至于他们是否能真正显示出来，却要取决于使用的浏览器和操作系统，其中操作系统是最根本的。
　　 4 、布尔类型：
　　 boolean 类型只有两个值 :false 和 true ，用过其他编程语言的朋友肯定对它们并不陌生。

 

2、   java当中的运算类型包括那些 ？

 

按 照运 算 符 功 能 来 分 ,基 本 的 运 算 符 有下 面 几 类 :

1.算 术 运 算 符 (+,-,*,/,%,++,--)

2.关 系 运 算 符 (＞,＜,＞=,＜=,==,!=)

3.布 尔 逻 辑 运 算 符 (!,&&,||)

4.位 运 算 符 (＞＞,＜＜,＞＞＞,&,|,^,～ )

5.赋 值 运 算 符 (=,及 其 扩 展 赋 值 运算 符 如 +=)

6.条 件 运 算 符 ( ?:)

7.其 它 (包 括 分 量 运 算 符 · ,下 标 运 算 符 [],实 例 运 算 符 instanc eof,内 存 分 配运 算 符 new,强 制 类 型转换 运 算 符 (类 型 ), 方 法调 用 运 算 符 () 等 ) //GOOD!

Java对 加运 算 符 进 行 了 扩 展 ,使 它 能 够 进行 字 符 串 的连 接,如 "abc"+"de",得到 串 "abcde"。 

与 C、 C++不 同 ,对 取 模 运 算 符 %来 说 ,其 操作 数可 以为浮点 数 , 如37.2%10=7.2。

i++与 ++i的 区 别:

i++在 使 用 i之 后 ,使 i的 值 加 1,因此 执 行 完 i++后 ,整 个 表达式的 值 为 i,而 i的 值变 为 i+1。

++i在 使 用 i之 前 ,使 i的 值 加 1,因此 执 行 完 ++i后 ,整 个 表达式和 i的 值 均 为 i+1。

关系 运算符:

关 系 运 算 符 用 来 比 较 两 个 值 ,返 回 布 尔类 型 的值true或 false。

Java中 ,任 何 数 据 类 型 的 数 据 (包 括 基 本类 型 和 组 合类 型)都可 以 通 过 ==或!=来 比 较 是 否 相 等 (这与 C、 C++不 同 )。

关 系 运 算 的 结 果 返 回 true或 false,而不是C、C++中 的 1或 0。

关 系 运 算 符 常 与 布 尔 逻 辑 运 算 符 一 起使 用 ,作 为 流 控 制语句 的 判 断条件 。 如

if( a＞b && b==c)

布尔逻辑 运算符:  // 且、或、非

对 于 布 尔 逻 辑 运 算 , 先 求 出 运 算 符 左 边的 表 达 式 的 值 , 对 或 运 算 如 果 为 true, 则 整 个 表 达 式 的结果 为 true, 不 必对 运 算 符 右 边 的 表 达 式 再 进 行 运 算 ; 同 样 , 对 与 运 算 , 如果左 边 表 达 式 的 值 为 false, 则 不 必对 右 边的 表 达式 求 值 , 整个表 达 式 的 结果 为 false。

下面的例子说明了关系 运算符和布尔逻辑 运算符的使用。

public class RelationAndConditionOp{

public static void main( String args[] ){

int a=25,b=3;

boolean d=a

System.out.println("a

int e=3;

if(e!=0 && a/e>5)

System.out.println("a/e = "+a/e);

int f=0;

if(f!=0 && a/f>5)

System.out.println("a/f = "+a/f);

else

System.out.println("f = "+f);

}

}

其运行结果为:

C:/＞ java RelationAndConditionOp

a＜b = false

a/e = 8

f = 0

注 意 :上 例 中 ,第 二 个 if语 句 在 运 行 时 不会 发 生 除 0溢 出的错 误 ,因 为 f!=0为false,所以 就 不 需 要 对 a/f进 行 运 算 。

位 运算符: // 待看!

位 运 算 符 用 来 对 二 进 制 位 进 行 操作 , Java中 提 供 了 如 下表所 示 的 位运 算符 :

位 运 算 符 中 ,除 　 ～ 　 以 外 ,其 余 均为 二元 运 算 符 。

操 作 数 只 能 为 整 型 和 字 符 型 数 据。

3.4.1 补 码

Java使 用补 码 来 表 示 二 进 制 数 ,在 补 码 表示 中 ,最高 位 为符号 位 ,正 数 的 符 号 位 为 0,负 数 为 1。 补码 的 规 定 如 下 :

对 正 数 来 说 ,最 高 位 为 0,其 余 各 位代 表数 值 本 身 (以 二 进制表 示 ),如 +42的补 码 为 00101010。

对 负 数 而 言 ,把 该 数 绝 对 值 的 补 码 按 位取 反 ,然 后 对 整个数 加 1,即 得 该 数的 补 码 。 如 -42的 补 码为 11010110 (00101010 按位 取 反 11010101 +1=11010110 )

用 补 码 来 表 示 数 ,0的 补 码 是 唯 一 的 ,都为 00000000。 (而 在原码 ,反码 表 示中 ,+0和 -0的 表 示 是 不 唯一 的 ,可 参 见 相 应 的书 籍 )。 而 且 可 以用 111111表 示 -1的 补码 (这也 是 补 码 与 原 码和 反 码 的 区 别 )。

3.4.2 按 位 取 反 运 算 符 ～

～ 　 是 一 元 运 算 法 ,对 数 据 的 每 个 二 进制 位 取 反 ,即 把 1变为 0,把 0变 为 1。

例 如 :

0010101

～

1101010

注 意 ,～ 运 算 符 与 - 运 算 符 不 同 ,～ 21≠ -21。

3.4.3 按 位 与 运 算 符 &

参 与 运 算 的 两 个 值 ,如 果 两 个 相 应 位 都为 1,则 该 位 的 结果为 1,否 则 为 0。即 :

0 & 0 = 0,0 &1 = 0,1 & 0 = 0,1 & 1 = 1

 

3.什么是封装、继承？

 

封装就是 信息隐藏，隐藏一个对象的本质，让用户不再注意那些细节；

继承就是 指定一个类与另一个类之间的关系。可以修改所需要类的状况和创建信的派生类的对象。这种能力是创建一个类层次的精华。在抽象的外部， 继承是系统设计的主要 部分。主要是为了可重用，代码移植，你能在保持父类原有特性及方法的前提下；添加新的特性，方法或者范围更小的约束

多态就是 具有老代码调用新代码的功能，他允许我们增强系统的功能而不破坏现有的代码。
2个好处：1、它能聚集公共的基类对象，并始终如一的处理他们。
2、老的代码可以使用新代码。

4. 堆，堆栈，栈的区别：
堆(heap)又叫堆栈，这是人们为了不在说时与栈的混淆才这么叫的,是一个应用程序可以自由分配的存储空间。栈（stack）,分配和释放由操作系统控制的存储空间.
一般认为在c中分为这几个存储区
1栈 - 由编译器自动分配释放
2堆 - 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收
3全局区（静态区），全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束释放
4另外还有一个专门放常量的地方。 - 程序结束释放
在函数体中定义的变量通常是在栈上，用malloc, calloc, realloc等分配内存的函数分配得到的就是在堆上。在所有函数体外定义的是全局量，加了static修饰符后不管在哪里都存放在全局区（静态区）,在 所有函数体外定义的static变量表示在该文件中有效，不能extern到别的文件用，在函数体内定义的static表示只在该函数体内有效。另外，函 数中的"adgfdf"这样的字符串存放在常量区。
比如：
int a = 0; 全局初始化区
char *p1; 全局未初始化区
main()
{

int b; 栈
char s[] = "abc";栈
char *p2; 栈
char *p3 = "123456"; 123456/0在常量区，p3在栈上。
static int c =0； 全局（静态）初始化区

p1 = (char *)malloc(10);
p2 = (char *)malloc(20);
分配得来得10和20字节的区域就在堆区。
strcpy(p1, "123456"); 123456/0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一块。
}
还有就是函数调用时会在栈上有一系列的保留现场及传递参数的操作。
栈的空间大小有限定，vc的缺省是2M。栈不够用的情况一般是程序中分配了大量数组和递归函数层次太深。有一点必须知道，当一个函数调用完返回后它会释放该函数中所有的栈空间。栈是由编译器自动管理的，不用你操心。
堆是动态分配内存的，并且你可以分配使用很大的内存。但是用不好会产生内存泄漏。并且频繁地malloc和free会产生内存碎片（有点类似磁盘碎片），因为c分配动态内存时是寻找匹配的内存的。而用栈则不会产生碎片。