[ Java学习 ] 一些Java程序 001

/*
老师之前给过我们一个学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学习 ] 实验 银行业务模拟

[Java学习 ] 破除思维定势之 C++ 和 Java 的差异 001

[Java学习 ] 破除思维定势之 C++ 和 Java 的差异 002

[Java学习 ] 破除思维定势之 C++ 和 Java 的差异 003

[Java学习 ] 包语句 package等语句的汇总整理

[Java学习 ] Java变量以及内存分配（非常重要）

[Java学习 ] 其他知识总结（重要）

[Java学习 ] “goto语句“ 和 “continue + 标号” 的不同待遇

[Java学习 ] toString方法 和 equals方法

 [ Java学习 ] 正则表达式与模式匹配

[Java学习 ] 查阅资料整理 001

[Java学习 ] 查阅资料整理 002

[Java学习 ] 一道Java好题的详细题解 001