一些java小代码

主要是温习上学期的基础知识，不能前学后忘呵呵、

创建一个简单的窗体
1）
import java.awt.*;
import javax.swing.*;

class hello extends JFrame {
	hello(){
		setTitle("hello");
		setVisible(true);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}
	
	public static void main(String[] args){
		new hello();
	}
}
当然也可以使用另外一种不是很推荐的方法：
import java.awt.*;
import javax.swing.*;

class hello {
	public static void main(String[] args) {
		JFrame frame= new JFrame();
		frame.setSize(100,100);
		frame.setTitle("hello");
		frame.setVisible(true);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}
}
效果都如下所示：
 

class hello {
	public static void main( String[] args ) {
		String[] he=new String[3];
		he[0]="1";
		he[1]="2";
		he[2]="3";
		
		for(String i : he){
			System.out.println(i);
		}

	}
}
输出结果：1 2 3 

import javax.swing.*;

public class hello {
	public static void main( String[] args ) {
		JOptionPane.showInputDialog("Rollen Holt");
		JOptionPane.showMessageDialog(null, "Welcome");
	}
	
}
 
 
import java.text.NumberFormat;

public class hello {
	public static void main( String[] args ) {
		NumberFormat format1 = NumberFormat.getCurrencyInstance();
		double a = 1000.1020;
		System.out.println(format1.format(a));

	}

}
输出结果：￥1,000.10



import java.math.*;
public class hello {
	public static void main( String[] args ) {
	long a=10000000000000l;
	long b=20000000000000l;
	BigInteger A=BigInteger.valueOf(a);
	BigInteger B= BigInteger.valueOf(b);
	
	// 对于大树类  不能直接用加减乘除，只能采用函数调用的形式
	BigInteger str=A.multiply(B);
	System.out.println(str);
	}
}
输出的结果：200000000000000000000000000

// 对象的引用传递 1
class hello{
	public static void main(String[] args){
		String str="hello";
		function(str);
		System.out.println(str);
	}
	
	private static void function(String str2){
		str2="world";
	}
}
输出结果：hello   （因为string类型是不可变的）
对象的引用传递2
// 对象的引用传递 2
class Demo {
	String str = "hello";   //注意这里是string类型，类类型
}

public class hello {
	public static void main( String[] args ) {
		Demo demo = new Demo();
		demo.str = "world";
		System.out.println(demo.str);
		function(demo);
		System.out.println(demo.str);
	}

	static void function( Demo demo ) {
		demo.str = "Rollen";
	}

}

输出的结果是：
world
Rollen
// 对象的引用传递 3
class Demo {
	int str = 1;            // 这里是int类型，是基本类型
}

public class hello {
	public static void main(String[] args) {
		Demo demo = new Demo();
		demo.str = 2;
		System.out.println(demo.str);
		function(demo);
		System.out.println(demo.str);
	}

	static void function(Demo demo) {
		demo.str = 3;
	}

}
输出的结果：
2
3
/**
 * @version 1.0
 * @author Rollen-Holt 判断两个一般对象是否相等
 * */

class hello{
	hello(){
		name = "";
		age = 0;
	}

	hello(String name, int age){
		this.age = age;
		this.name = name;
	}

	public boolean compare(hello he){
		if (he == null) {
			return false;
		}
		if (he == this) {  //如果两个对象在同一个地址的话，一定是相等的
			return true;
		}  // 否则的话，就要逐个比较内容了
		if (this.name.equals(he.name) && (this.age == he.age)) {
			return true;
		} else {
			return false;
		}
	}

	public static void main(String[] args){
		hello h1 = new hello("name1", 12);
		hello h2 = new hello("name2", 18);
		if (h1.compare(h2)) {
			System.out.println("equal");
		} else {
			System.out.println("not equal");
		}
	}

	private String name;
	private int age;
}
输出的结果：not equal

有时候我们还需要在继承的情况下判断对象是否相等
/**
 * @author Rollen-Holt
 * 继承中的对象的比较
 */
class Person{
	
	Person(String name, int age){
		this.age=age;
		this.name=name;
	}
	
	public boolean equals(Object obj){
		if(obj==null){
			return false;
		}
		if(this==obj){
			return true;
		}
		if(!(obj instanceof Person)){
			return false;
		}
		Person per =(Person)obj;
		if(this.name.equals(per.name)&&(this.age==per.age)){
			return true;
		}else{
			return false;
		}
	}
	
	public String toString(){
		return this.name+"	"+this.age;
	}
	
	private String name;
	private int age;
}

class hello{
	public static void main(String[] a){
		Person per1=new Person("Rollen",12);
		Person per2=new Person("Rollen",12);
		if(per1.equals(per2)){
			System.out.println("equals");
		}else{
			System.out.println("Not equals");
		}
	}
}


/**
 * @version 1.0
 * @author Rollen-Holt 代码块的使用
 * */

class hello{
	static{
		System.out.println("hello");
		System.exit(1);
	}
}

/**
 * @version 1.0
 * @author Rollen-Holt 代码块的使用，注意调用顺序
 * */

class hello{
	{
		// 普通代码块
		System.out.println("普通代码块");
	}
	static{
		//静态代码块
		System.out.println("静态代码块");
	}
	hello(){
		//构造代码块
		System.out.println("构造代码块");
		
	}
	public static void main(String[] a0){
		hello he=new hello();
		hello he1=new hello();
		System.out.println("主函数");
	}
}
输出结果：
静态代码块   // 静态代码块指调用一次
普通代码块
构造代码块
普通代码块
构造代码块
主函数


/**
 * @version 1.0
 * @author Rollen-Holt 使用static 定义内部类 ，但是静态内部类只能访问外部类的静态属性和方法
 * */

class hello{
	private static void say(){
		System.out.print("hello");
	}

	private void say1(){
		System.out.print("hello1");
	}
  
	static class inner{
		void getSay(){
			say();
		}
		
//		void getSay1(){
//			say1();
//		}
	}
	public static void main(String[] a0){
		new hello.inner().getSay();
        //new hello.inner().getSay1(); // 静态内部类不能发访问外部类的非静态成员和方法
		
	}
}

/**
 * @version 1.0
 * @author Rollen-Holt 
 * 继承中的方法重写的问题
 * */
class Demo{
	void say(){
		System.out.println("Demo");
	}
}

class hello extends Demo{
	public void say(){  //注意这里的public，重写的时候访问权限不能小于原来的
		System.out.println("hello");
	}
	public static void main(String[] a0){
		new hello().say();
	} 
}

/**
 * @author Rollen-Holt 在抽象类中定义构造方法
 */
abstract class Demo{
	public Demo(){
		System.out.println("Demo");
	}

	public void say(){
		System.out.println("Rollen");
	}
}

class hello extends Demo{
	public void say(){
		super.say();
		System.out.println("Holt");
	}

	public static void main(String[] a){
		new hello().say();
	}
}
输出的结果：
Demo
Rollen
Holt

/**
 * @author Rollen-Holt this 关键字的使用
 */

class hello{
	hello(){
		name = "";
		age = 0;
	}

	// 此处使用this访问类属性
	hello(String name, int age){
		this.age = age;
		this.name = name;
	}

	// 此处使用this调用构造函数
	hello(String name){
		this(name, 0);
	}
    
	public String getName(){
    	return name;
    }

	public static void main(String[] a){
		hello he = new hello("Holt");
		System.out.println(he.getName());
	}

	private int age;
	private String name;
}

关于接口的一点点啰嗦：
//接口中的方法必须是public。如果不写public的话，默认也是public的
interface A{
	public static final String name="Rollen";
	public abstract void say();
}
接口其实可、可以简写为下面的形式：
interface A{
	String name = "Rollen";
	void say();
}

/**
 * @author Rollen-Holt
 * 接口的一个例子
 */

// 接口中的方法必须是public。如果不写public的话，默认也是public的
interface A{
	String name = "Rollen";
	void say();
}

class hello implements A{
	public static void main(String[] a){
		new hello().say();
	}

	@Override
	public void say(){
		System.out.println(name);

	}
}

/**
 * @author Rollen-Holt
 * 对象的多态性
 * 对象的向上传递
 */

class Demo{
	public void say(){
		System.out.println("Rollen");
	}
}
class hello extends Demo{
	public void say(){
		System.out.println("Holt");
	}
	public static void main(String[] a){
		hello he=new hello();
		Demo demo=new Demo();
		demo=he;
		demo.say();
	}

	
}
输出结果Holt
/**
 * @author Rollen-Holt
 * 对象的多态性
 * 对象的向下传递
 */

class Demo{
	public void say(){
		System.out.println("Rollen");
	}
}
class hello extends Demo{
	public void say(){
		System.out.println("Holt");
	}
	public static void main(String[] a){
		Demo demo=new hello();
		//但是如果将上面的这句换为： Demo demo=new Demo();
		//将会出现错误
		hello he=(hello)demo;
		he.say();
	}

	
}
输出结果:Holt

/**
 * @author Rollen-Holt
 */
// 在抽象类内部也可以定义多个抽象类或者是接口，
//在接口的内部也可以定义多个接口或者是抽象类

abstract  class A{
	public abstract void sayA();
	interface B{
		public void sayB();
	}
}

class X extends A{
	public void sayA(){
		System.out.println("A");
	}
	class Y implements B{
		public void sayB(){
			System.out.println("B");
		}
	}
}
class hello{
	public static void main(String[] a){
		A.B demo=new X().new Y();
		demo.sayB();
	}
}

/**
 * @author Rollen-Holt
 */
// 在抽象类内部也可以定义多个抽象类或者是接口，
// 在接口的内部也可以定义多个接口或者是抽象类
/*
 * 在一个接口中实现抽象类
 */
interface A{
	public void sayA();
	abstract class B{
		public abstract void sayB();
	}
}

class X implements A{
	public void sayA(){
		System.out.println("A");
	}
	class Y extends B{
		public void sayB(){
			System.out.println("B");
		}
	}
}
class hello{
	public static void main(String[] a){
		A.B demo =new X().new Y();
		demo.sayB();
	}
}

Object类提供的equals（）方法默认是比较地址的。

/**
 * @author Rollen-Holt
 * 使用object 接收接口
 */
interface A{
	public void say();
}

class B implements A{
	public void say(){
		System.out.println("A");
	}
}

class hello{
	public static void main(String[] args){
		A a=new B();
		Object obj=a;
		A demo=(A)obj;
		demo.say();  //输出A
	}
}

/*
 * 这个实例说明，虽然接口不能继承类，但是接口仍然是Object的子类。
 * 因为接口本身就是引用数据类型 所以可以进行向上的转型操作
 * 
 */

/**
 * @author Rollen-Holt 使用object 接收数组
 */

class hello{
	public static void print(Object obj){
		if (obj instanceof int[]) {
			int[] array = (int[]) obj;
			for(int temp : array) {
				System.out.println(temp + "\t");
			}
		}
	}

	public static void main(String[] args){
		int temp[] = { 1, 2, 3, 4, 5 };
		Object obj = temp;
		print(obj);
	}
}

/*
 * Object 可以接受任何引用类型
 */


关于异常的一点点小解说：
Exception在程序中必须使用try …catch语句进行处理
但是RuntimeException可以不使用try…catch进行处理，如果期间有异常产生，则直接提交到JVM
一点点小建议：
对于RuntimeException也使用try…catch语句进行处理

关于使用分别倒入和使用“*”导入那个效率高的问题:
其实效率是一样的，因为即使对于“*”导入的，也是程序自动加载的。而不需要的类不会被导入到程序。