老师之前给过我们一个学Java的建议：
推荐大家看Blackboard上的课件，特别是PPT上的源程序，建议大家拷贝到Eclipse下运行，并且多玩程序，熟悉各种不同用法。
说来惭愧，又是知道但没做到的道理...
趁着今天，我找了源程序来看了一下，并且把我觉得，PPT上的，比较“好玩”的Java程序整理一下
另外，发现老师当时给我们的实验指导里，还有这么一段建议，发出来与君共勉~
学编程没有笨同学，只有懒同学。什么时候觉得很糊涂，就需要去看书，看程序，然后通过总结（整理知识点，归纳常见做法）理顺思路，而不是又感叹一遍自己好笨之类的。以前C和C++没学好的同学，不要老认为自己基础不好就学不好java，只是需要花更多的时间看书看程序。学习语言的套路：看书，看程序，总结，练习，成为高手。
<这段话有点扎心了，想到我之前一直没有按照老师所说的建议，把程序下载下来，“改改玩玩，有意思的动手敲一敲”，可不就是懒么？>
以及，老师给了别的学 Java 的建议，也一并放出来：
1.google或者百度
A 先精后粗
B 先中后英
C 信息筛选，搜索出来的结果不见得能够完全匹配，建议大家多阅读前几页的搜索结果，多打开几个网页看看。一般超过3页还没有找到合适的答案，或许应该调整一下关键词，或者放粗整个搜索的结果了。
2.BBS上问高手
推荐：http://www.csdn.net/ 中国最有名的技术论坛
或者直接google或百度搜索，关键词“java论坛”“java bbs”，然后在搜索结果里选择那些活动频繁的论坛。
---------好的，言归正传，建议放完了就放代码---------
*/
/* 由这段代码引申出的知识：
* 1. args的参数
* 2. NaN的意义，以及在什么情况下会出现
* 3. Long的几种方法
*/
public class test
{
public static void main(String args[ ]){
double n,sum=0.0 ;
System.out.println("hava a test " + "args.length=" + args.length);
for(int i=0;i<args.length;i++)
{
sum=sum+Double.parseDouble(args[i]);
System.out.println("why???");
System.out.println("args[i]=" + args[i]);
}
n=sum/args.length;
System.out.println("平均数:"+n);
int number=8658;
String binaryString=Long.toBinaryString(number);
System.out.println(number+"的二进制表示:"+binaryString);
System.out.println(number+"的八进制表示:"+Long.toOctalString(number));
System.out.println(number+"的十六进制表示:"+Long.toString(number,16));
}
}
//java实现连续输入
//其实倒也不是多难的程序，就是来看看，怎么样实现连续输入的循环吧
//这段代码的连续输入，可以用任意一个字符，例如 ! 或者 * 来结束
package test;
import java.util.*;
public class test{
public static void main (String args[ ]){
Scanner reader=new Scanner(System.in);
double sum=0;
int m=0;
while(reader.hasNextDouble()){
double x=reader.nextDouble();
m=m+1;
sum=sum+x;
}
System.out.printf("%d个数的和为%f
",m,sum);
System.out.printf("%d个数的平均值是%f
",m,sum/m);
}
}//按照题目要求编写 Employee类
class Employee
{
String name, sex;
int salary;
Employee(String n, int s, String sex)
{
name = n;
salary = s;
this.sex = sex;
}
void show()
{
System.out.println("该雇员的姓名为： " + name);
System.out.println("该雇员的薪水为： " + salary);
System.out.println("该雇员的性别为： " + sex);
}
}
public class Demo
{
public static void main(String args[])
{
Employee e = new Employee("张三", 8000, "男");
e.show();
}
}//帮助理解数组之间的赋值
public class test{
public static void main(String args[ ]){
int [] a={1,2,3};
int [] b={10,11};
System.out.println("数组a的引用是:"+a);
System.out.println("数组b的引用是:"+b);
System.out.printf("b[0]=%-3db[1]=%-3d
",b[0],b[1]);
b=a;
System.out.println("数组a的引用是:"+a);
System.out.println("数组b的引用是:"+b);
b[1]=888;
b[2]=999;
System.out.printf("a[0]=%-5da[1]=%-5da[2]=%-5d
",a[0],a[1],a[2]);
System.out.printf("b[0]=%-5db[1]=%-5db[2]=%-5d
",b[0],b[1],b[2]);
}
}
//按照题目要求编写两个类
class Employee
{
String name, sex;
int salary;
Employee(String n, int s, String sex)
{
name = n;
salary = s;
this.sex = sex;
}
void show()
{
System.out.println("该雇员的姓名为： " + name);
System.out.println("该雇员的薪水为： " + salary);
System.out.println("该雇员的性别为： " + sex);
}
}
class Manager extends Employee
{
String department;
Manager(String n, int s, String sex, String d)
{
super(n, s, sex);
department = d;
}
void show()
{
System.out.println("该经理的姓名为： " + name);
System.out.println("该经理的薪水为： " + salary);
System.out.println("该经理的性别为： " + sex);
System.out.println("该经理的部门为： " + department);
}
}
public class Demo
{
public static void main(String args[])
{
Employee e = new Employee("张三", 8000, "男");
e.show();
System.out.println();
Manager m = new Manager("李四", 12000, "男", "销售");
m.show();
}
}//二分法找元素在数组中的位置
//嗯，之所以列出，是因为这段代码用到了二分法，其他的地方，好像没有特别可圈可点之处
import java.util.Scanner;
public class test{
public static void main(String args[]){
int n,start,end,middle;
int a[]={-2,1,4,5,8,12,17,23,45,56,90,100};
start=0;
end=a.length;
middle=(start+end)/2;
int count=0;
Scanner reader=new Scanner(System.in);
System.out.print("请输入一个整数:");
n=reader.nextInt();
while(n!=a[middle]){
if(n>a[middle]){
start=middle;
}
else if(n<a[middle]){
end=middle;
}
middle=(start+end)/2;
count++;
if(count>a.length/2)
break;
}
if(count>a.length/2)
System.out.println(n+"不在数组中");
else
System.out.println(n+"是数组中的第"+middle+"个元素");
}
}
//继承例1
class A{
protected double x=8.0,y=0.888888;
public void speak(){
System.out.println("我喜欢NBA");
}
public void cry(){
y=x+y;
System.out.printf("y=%f
",y);
}
}
class B extends A{
int y=100,z;
public void speak(){
z=2*y;
System.out.println("I love This Game");
System.out.printf("y=%d,z=%d",y,z);
}
}
class test{
public static void main(String args[ ]){
B b=new B();
b.cry();
b.speak();
}
}
//程序的输出结果为：
//y=8.888888
//I love This Game
//y=100,z=200 (注意最后一行的输出，很容易弄错，其实调用 void speak()时，由于是调用 B类里的函数，因而所用的 y,也应该是 B类里的成员变量y,应该取10)//继承例2
class A{
public double y=11.456789;
public void f(){
y=y+1;
System.out.printf("y是double型的变量,y=%f
",y);
}
}
class B extends A{
int y=0;
public void g(){
y=y+100;
System.out.printf("y是int型的变量,y=%d
",y);
}
}
class test{
public static void main(String args[ ]){
B b=new B();
b.y=200;
b.g(); //调用子类新增的方法
b.f(); //调用子类继承的方法
}
}
//最后输出结果为：
//y是int型的变量,y=300
//y是double型的变量,y=12.456789
//题目：计算一个圆和一个矩形的面积之和
//为了直接用 PI而导入包 Math
import static java.lang.Math.*;
abstract class Geometry
{
abstract public double getArea();
}
class Rect extends Geometry
{
double length, width;
Rect(double l, double w)
{
length = l; width = w;
}
public double getArea()
{
return length * width;
}
}
class Circle extends Geometry
{
double radius;
Circle (double r)
{
radius = r;
}
public double getArea()
{
return PI * radius * radius;
}
}
class TotalArea
{
final int SIZE = 2;
Geometry tuxing[] = new Geometry[SIZE];
TotalArea()
{
tuxing[0] = new Circle(5);
tuxing[1] = new Rect(4, 8);
}
public double computerTotalArea()
{
double ans = 0.0;
for (int i = 0; i < SIZE; i++)
ans += tuxing[i].getArea();
return ans;
}
}
public class Test
{
public static void main(String args[])
{
TotalArea test = new TotalArea();
System.out.println("测试结果，该圆和该矩形的面积之和为： " + test.computerTotalArea() );
}
}//静态变量和实例变量的区别
class A
{
static int a = 0;
int b;
public A (int a)
{
this.a = a;
}
public A (int a, int b)
{
this(a);
this.b = b;
}
public int add()
{
return a + b;
}
public void display()
{
System.out.println("a="+a+", b=" + b);
System.out.println("a+b=" + this.add());
}
}
public class test
{
public static void main(String args[])
{
A a = new A(10, 5);
A b = new A(20, 8);
a.display();
b.display();
}
}//继承例4
lass A{
double n;
int m;
void f(){
System.out.printf("子类继承方法f(),n=%f,m=%d
",n,m);
}
void g(){
System.out.printf("你好，n=%f,m=%d
",n,m);
}
}
class B extends A{
int n=12;
void g(){
System.out.printf("子类重写方法g(),n=%d,m=%d
",n,m);
}
void cry(){
System.out.printf("子类新增的方法,n=%d,m=%d
",n,m);
}
}
public class test{
public static void main(String args[ ]){
A a;
a=new B(); //a是子类对象的上转型对象
a.n=0.618; //操作子类隐藏的double类型成员n
a.m=200; //操作子类继承的成员m,等价于b.m=200;
a.f(); //调用子类继承的方法,等价于b.f();
a.g(); //调用子类重写的方法,等价于b.g();
B b=(B)a; //上转型对象强制转换成子类对象
b.n=555; //操作子类新增的int类型成员n
b.cry(); // a.cry(); 是非法的
}
}
//继承例3
class A{
int m=0,n=0;
long f(){
return m+n;
}
}
class B extends A{
int m=1,n=1;
long f(){
long result=0;
super.m=10;
super.n=20;
result=super.f()+(m+n);
return result;
}
long g(){
long result=0;
result=super.f();
return result/2;
}
}
public class test{
public static void main(String args[ ]){
B b=new B();
b.m=3;
b.n=7;
long resultOne=b.g();
long resultTwo=b.f();
long resultThree=b.g();
System.out.println("resultOne="+resultOne);
System.out.println("resultTwo="+resultTwo);
System.out.println("resultThree="+resultThree);
}
}
//最后输出结果为：
//resultOne=0
//resultTwo=40
//resultThree=15//三角形形状问题
import java.util.*;
public class test{
public static void main (String args[ ]){
Scanner reader=new Scanner(System.in);
double a=0,b=0,c=0;
System.out.print("输入边a:");
a=reader.nextDouble();
System.out.print("输入边b:");
b=reader.nextDouble();
System.out.print("输入边c:");
c=reader.nextDouble();
if(a+b>c&&a+c>b&&b+c>a){
if(a*a==b*b+c*c||b*b==a*a+c*c||c*c==a*a+b*b){
System.out.printf("%-8.3f%-8.3f%-8.3f构成是直角三角形",a,b,c);
}
else if(a*a<b*b+c*c&&b*b<a*a+c*c&&c*c<a*a+b*b){
System.out.printf("%-8.3f%-8.3f%-8.3f构成锐角三角形",a,b,c);
}
else{
System.out.printf("%-8.3f%-8.3f%-8.3f构成钝角三角形",a,b,c);
}
}
else{
System.out.printf("%f,%f,%f不能构成三角形",a,b,c);
}
}
}
/*
上面的是老师发的课件里的配套代码
可是我有些看不下去了...double不是有精度损失，不能用 == 来判等的吗？
于是果断加了 EPS，自己动手敲一次这个程序
(我还自己加上了 等腰、等边、等腰直角三角形的判断
也就是说，如果它是特殊三角形，我就会输出它最特殊的那个类型
这个嘛，就是等腰直角三角形、等边三角形这种，我不会只输出等腰三角形的
)
几个注意点：
1. double 类型的判等
2. 只要在源文件顶部加上
import static java.lang.Math.*;
则不必在数学方法名和常量名前添加前缀"Math"
[来自《Java核心技术卷1》P40 的提示栏]
*/
package test;
import java.util.*;
import java.util.Arrays;
import static java.lang.Math.*;
class triangle
{
final double EPS = 1e-6;
double side[] = new double[3];
boolean ifSame(double a, double b)
{
return abs(a - b) < EPS; // double 的浮点精度损失尤其需要注意，一定不要用 == 来判等，而是应该和 EPS 进行比较
}
void inputSide() //输入3边长并排序
{
Scanner reader = new Scanner(System.in);
System.out.println("请输入三角形的三边，用空格或回车隔开3个数据");
for ( int i = 0; i < 3; i++ )
{
side[i] = reader.nextDouble();
}
Arrays.sort(side);
// System.out.println("After being sorted, the three sides are ");
// for (int i = 0; i < 3; i++)
// System.out.print(side[i] + " ");
}
void outputType() //输出三角形类型
{
inputSide();
if ( side[0] + side[1] < side[2] || ifSame ( side[0] + side[1], side[2] ) )
{
System.out.println("输入的三边无法构成三角形");
return;
}
if ( ifSame (side[0], side[2] ) )
{
System.out.println("该三角形是等边三角形");
return;
}
if ( ifSame (side[0], side[1] ) || ifSame (side[1], side[2] ) ) //等腰
{
if ( ifSame ( pow( side[0], 2 ) + pow( side[1], 2 ), pow(side[2], 2 ) ) )
System.out.println("该三角形是等腰直角三角形");
else
System.out.println("该三角形是等腰三角形");
return;
}
if ( ifSame ( pow( side[0], 2 ) + pow( side[1], 2 ), pow(side[2], 2 ) ) )
{
System.out.println("该三角形是直角三角形");
return;
}
if ( pow( side[0], 2 ) + pow( side[1], 2 ) < pow(side[2], 2) )
System.out.println("该三角形是锐角三角形");
else
System.out.println("该三角形是钝角三角形");
}
}
public class test
{
public static void main (String args[])
{
triangle tp = new triangle(); // tp:: temp
tp.outputType();
}
}
/* 字符串 String 类有关知识
* 这段代码的要点在于：
* 1. s1 == s2 和 s1.equals(s2) 的区别
* 2. s1 = new String("..."); 和 s1 = "...";的区别
* 3. 字符串的 contains 函数的使用
*/
public class test{
public static void main(String args[ ]){
String s1,s2;
s1=new String("we are students");
s2=new String("we are students");
System.out.print(s1.equals(s2)+" ");
System.out.println(s1==s2);
String s3,s4;
s3="how are you";
s4="how are you";
System.out.print(s3.equals(s4)+" ");
System.out.println(s3==s4);
System.out.print(s1.contains(s3)+" ");
System.out.println(s2.contains("stu"));
}
}
//数据类型与精度损失
public class test{
public static void main (String args[ ]){
byte a=120;
short b=130;
int c=2200;
long d=8000;
float f;
double g=0.1234567812345678;
a=(byte)b; //导致精度的损失
c=(int)d; //未导致精度的损失
f=(float)g; //导致精度的损失
System.out.println("a="+a);
System.out.println("c="+c);
System.out.println("f="+f);
System.out.println("g="+g);
}
}
//图形界面 比较好玩
例子2
import java.applet.*;
import java.awt.*;
public class Boy extends Applet
{
public void paint(Graphics g)
{
g.setColor(Color.blue);
g.drawString("Java是一门很优秀的语言",12,30);
g.setColor(Color.red);
g.drawString("我一定认真学习Java",22,56);
}
}
//希腊字母表 数学公式里可能会用到
public class test{
public static void main (String args[ ]){
char c='α';
System.out.println("字母"+c+"在unicode表中的顺序位置:"+(int)c);
System.out.println("字母表：");
for(int i=(int)c;i<c+25;i++){
System.out.print(" "+(char)i);
}
}
}
//异常 代码1
//主要是直接编写异常类，以及 throw catch 语句的使用
class MyException extends Exception
{
String message;
MyException(int n)
{
message=n+"不是正数";
}
public String getMessage()
{
return message;
}
}
class A
{
public void f(int n) throws MyException
{
if(n<0)
{
MyException ex=new MyException(n);
throw(ex); //抛出异常，结束方法f的执行
}
double number=Math.sqrt(n);
System.out.println(n+"的平方根:"+number);
}
}
public class test
{
public static void main(String args[])
{
A a=new A();
try
{
a.f(28);
a.f(-8);
}
catch(MyException e)
{
System.out.println(e.getMessage());
}
}
}
//程序输出结果为
//28的平方根:5.291502622129181
//-8不是正数-------------------------------其他相关文章------------------------------
[Java学习 ] 类的其他文章汇总（都是超链接，可直接点击）：
[Java学习 ] 破除思维定势之 C++ 和 Java 的差异 001
[Java学习 ] 破除思维定势之 C++ 和 Java 的差异 002
[Java学习 ] 破除思维定势之 C++ 和 Java 的差异 003
[Java学习 ] “goto语句“ 和 “continue + 标号” 的不同待遇
[Java学习 ] toString方法 和 equals方法