JAVA（五）程序

一、编写第一个java程序

public class Hello
{
    pubic static void main(String args[])
    {
        System.out.println("Hello World");    
    }    
}

二、简单的java范例

public class TestJava
{
    public static void main(String[] args) //java操作的一个简单范例，输出和乘方
    {
        int num = 10;    //定义整型变量
        num = 30; //修改变量内容
        System.out.println("num的内容是：" + num); //输出变量内容
        System.out.println("num * num = " + num * num );    //输出乘方
    }
}
/*
    程序运行结果：
    num的内容是：30
    num * num = 900
*/

class DataDemo02
{
    public static void main(String[] args)
    {
        int max = Integer.MAX_VALUE;     //得到整型的最大值
        System.out.println("整型的最大值：" + max);     //输出最大值
        System.out.println("整型的最大值 + 1：" + (max + 1));        //最大值加1
        System.out.println("整型的最大值 + 2：" + (max + 2));        //最大值加2
    }    
}
/*
    输出结果是：
    整型的最大值：2147483647
    整型的最大值 + 1：-2147483648
    整型的最大值 + 2：-2147483647
*/

class DataDemo02
{
    public static void main(String[] args)
    {
        int max = Integer.MAX_VALUE;     //得到整型的最大值
        System.out.println("整型的最大值：" + max);     //输出最大值
        System.out.println("整型的最大值 + 1：" + (max + 1));        //最大值加1
        System.out.println("整型的最大值 + 2：" + (max + 2L));        //最大值加2，变为long型
        System.out.println("整型的最大值 + 2：" + ((long)max + 2));        //强制转换为long型
    }    
}
/*
    输出结果是：
    整型的最大值：2147483647
    整型的最大值 + 1：-2147483648
    整型的最大值 + 2：2147483647
    整型的最大值 + 2：2147483647
*/

public class DataDemo04
{
    public static void main(String[] args)
    {
        char ch1 = 'a';    //定义字符
        char ch2 = 97;    //定义字符，整型转字符
        System.out.println("ch1 = " + ch1); //打印输出
        System.out.println("ch2 = " + ch2);    //打印输出
    }    
}
/*
    输出内容：
    ch1 = a
    ch2 = a
*/

public class DataDemo06
{
    public static void main(String[] args)
    {
        float num = 3.0f;        //定义float型变量
        System.out.println("两个小数相乘：" + num　＊ num); //计算两数相乘
    }    
}

/*
    输出内容：
        两个小数相乘：9.0
*/

public class DataDemo07
{
    public static void    main(String[] args)
    {
        boolean flag = true;    //定义布尔型变量
        System.out.println("flag = " + flag); //打印输出    
    }
}
/*
    输出内容：
        flag = true
*/

public class DataDemo08
{
    public static void main(String[] args)
    {
        int x = 30;    //定义整型变量
        int float = 22.19f; //定义浮点型变量
        System.out.println("x/y = " + (x/y)); //除法操作
        System.out.println("10/3.5 = " + (10/3.5)); //直接使用常量进行除法
        System.out.println("10/3 = " + (10/3));    //直接使用常量进行除法
    }    
}
/*
    输出内容：
        x/y = 1.3519603
        10/3.5 = 2.857142857142857
        10/3 = 3
*/

public class DataDemo09
{
    public static void main(String[] args)
    {
        String str = "lixinghua ";    //定义字符变量
        int x = 30;    //定义整型变量
        str = str + x;    //改变字符串变量内容
        System.out.println("str = " + str);    //打印输出
    }    
}
/*
    输出内容：
        str = lixinghua 30
*/

public class DataDemo11
{
    public static void main(String[] args)
    {
        float f = 30.3f; //定义浮点型变量
        int x = (int) f;    //强制转换为int型
        System.out.println("x = " + x); //输出转型之后的值
        System.out.println("10/3 = " + ((float)10/3));    //常量计算使用强制类型转换
    }    
}
/*
    输出内容：
        x = 30
        10 / 3 = 3.3333333
*/

public class ForNestedDemo
{
    public static void main(String[] args)
    {
        for(int i = 1; i <=9; i++)    //第一层循环
        {
            for(int j = 1; j <= i; j++)    //第二层循环
            {
                System.out.println(i + "*" + j + "=" + (i * j) + "	");    
            }    
            System.out.printf("
"); //换行
        }    
    }
}

public class ArrayDemo01
{
    public static void main(String[] args)
    {
        int score[] = null;
        
        score = new int[3];
        System.out.println("score[0] = " + score[0]);    
        System.out.println("score[1] = " + score[1]);
        System.out.println("score[2] = " + score[2]);
        for(int x=0; x<3; x++)
        {
            System.out.println("score["+x+"] = "+score[x]);
        }
    }    
}

public class ArrayDemo05
{
    public static void main(String[] args)
    {
        int score[] = {67,89,87,69,90,100,30,50};    //静态初始化数组
        int max = 0;    //定义变量保存最大值
        int min = 0;    //定义变量保存最小值
        max = min = score[0];    //把第一个元素的内容赋值给max和min
        
        for(int x=0; x<score.length; x++)    //循环求出最大和最小
        {
            if(score[x]>max)    //依次判断后续元素是否比max大
            {
                max = score[x];  span class=  //如果大，则修改max内容
            }    
            if(score[x]<min)    //一次判断后续元素是否比min小
            {
                min = score[x];        //如果小，则修改min内容
            }
        }    
        System.out.println("最高成绩：" + max);    //输出最大值
        System.out.println("最低成绩: " + min);    //输出最小值
    }    
}

public class ArrayDemo06
{
    public static void main(String[] args)
    {
        int score[] = {67,89,87,69,90,100,75,90};    // 声明数组
        for(int i=1; i<score.length; i++)    //循环判断
        {
            for(int j=0; j<score.length; j++)    //交换位置
                {
                    if(score[i]<score[j])
                    {    int temp = score[i];
                        score[i] = score[j];
                        score[j] = temp;
                    }    
                }
        }
        for(int i=0; i<score.length; i++)    //数组输出
             System.out.println(score[i] + "	");
    }    
}

class A
{
    public  int i = 10;
    protected  int j = 20;
    
    public void e(int i, int j)
    {
        this.i = i;
        this.j = j;
    }
    public void f()
    {
        System.out.printf("%d",this.i);    
    }    
    
    public void g()
    {
        f();
        System.out.printf("%d",this.j);    
    }
}

class D
{
    public static void main(String[] args)
    {
        A aa1 = new A();
        aa1.e(50,60);
        aa1.g();
    }    
}

class StaticDemo 
{
    static int a = 42;
    static int b = 99;
    
    static void callme() 
    {
        System.out.println("a = " + a);
    }
}

class StaticByName 
{
    public static void main(String args[]) 
    {
        StaticDemo.callme();
        System.out.println("b = " + StaticDemo.b);
    }
}

/*
    输出内容是：
    a = 42
    b = 99
    
    static成员是不能被其所在class创建的实例访问的。

如果不加static修饰的成员是对象成员，也就是归每个对象所有的。

加static修饰的成员是类成员，就是可以由一个类直接调用，为所有对象共有的


*/

class A
 {
     public int i = 10;    
     private static A aa =new A(); // aa 是否是A对象的属性
     
     private A()
     {
     }
     public static    A getA()  //static  一定不能省 如果省略就只能通过对象去调用它了
     {
         return aa;    
     }
 }
 
 public class D
 {
     public static void main(String[] args)
     {
         A aa1 = A.getA();    
         A aa2 = A.getA();
         
         aa1.i = 99;
             System.out.printf("%d
",aa2.i);
     }    
 }

class A
{
    private int i;
    private static int count = 0;
    
    public A()
    {
        ++count;    
    }
    
    public A(int i)
    {
        this.i = i;
        ++count;    
    }
    
    public static int getcount()
    {
        //return 返回A对象的个数
        return count;    
    }
        
}
class D
{
    public static void main(String[] args)
    {
        A aa = new A();
        A bb = new A();
        System.out.printf("%d",aa.getcount());
    }
}

class Human
{
    public String name = "晓得";
    public int age = 30;    
}

class Student extends Human
{
    public double score = 66.6;
}

class Graduate extends Student
{
    public int c = 100;    
}

class E
{
    public static void main(String[] args)
    {
        Graduate gd = new Graduate();
         System.out.printf("%s  %d  %f",gd.name,gd.age,gd.score);    
    }    
}
/*
    一个新类从已有的类那里获得其已有的属性和方法，这中现象叫类的继承
    这个新类别称为子类，也叫派生类，已有的哪个类叫做父类，也叫做基类
    继承的好处
        代码得到极大的重用
        形成一种类的层次体系结构，为多态创造条件
*/

class A
{
    public int i,j;
    
    public A(int i,int j)
    {
        this.i = i;
        this.j = j;
    }    
}

class B extends A
{
    public int k;
    
    public B(int i, int j, int k)
    {
        super(i,j);
        this.k = k;    
    }        
    
    public void g()
    {
        System.out.printf("%d %d %d",i,j,k);    
    }
}



class E
{
    public static void main(String[] args)
    {
        B aa = new B(3,3,4);
        aa.g();
    }    
}

/*
    总结：
        1、每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的
           构造函数，那么在编译的时候就会报错。

        2、如果显示的写出super();语句，则必须保证该语句是第一条语句，否则会出错

        3、super();如果不写，则编译器会自动添加,所以此时如果父类没有无参的构造函数就会出错

        4、既可以显示写super();前提是父类必须有无参的构造函数
           也可以显示写super(实参); 前提是父类必须有带参的构造函数

        5、调用父类的构造函数的语句必须借助于super,不能直接写父类的类名，这与C++不同，
*/

/*
    2008年6月6日8:42:07
    super的使用
*/

class A
{
    A()
    {
        System.out.println("AAAA");
    }

    A(int i)
    {
    }
}

class B extends A
{
    B()
    {
        super(2); //如果把该语句注释掉的化，则编译器默认的是自动隐藏调用super(); 但如果父类没有无参的构造函数，则会报错
                  //一个子类的构造函数中只能出现一个 super(....)
        System.out.println("BBBB");
    }
}

class C extends B
{
    C() 
    {
        //int k = 10; //如果该语句生效 则会出错，因为会导致super()语句不是构造函数的第一条语句
        
        super();  //35行  每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有无参的构造函数，那么在编译的时候就会报错。
                  //super();语句可以写，也可以不写，不写的化，系统会自动调用的
                  //如果显示写出来的话，编译器要求该语句前面不能加任何语句，也就是说该语句必须保证是第一条语句
                  // super()也可以改为super(2); 但前提是父类必须有带一个参数的构造函数，否则也会报错                
                  //如果把35行改为 super(2); 编译时就会报错!  

        System.out.println("CCCC");
    }
}

class  TestSuper_1
{
    public static void main(String[] args) 
    {
        C cc = new C();

        //System.out.println("Hello World!");
    }
}
/*
    在j2sdk1.4.2_16中的运行结果是：
-----------------------
BBBB
CCCC
-----------------------

     总结：
        1、每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的
           构造函数，那么在编译的时候就会报错。

        2、如果显示的写出super();语句，则必须保证该语句是第一条语句，否则会出错

        3、super();如果不写，则编译器会自动添加,所以此时如果父类没有无参的构造函数就会出错

        4、既可以显示写super();前提是父类必须有无参的构造函数
           也可以显示写super(实参); 前提是父类必须有带参的构造函数

        5、调用父类的构造函数的语句必须借助于super,不能直接写父类的类名，这与C++不同，
*/

class Human
{
    private String name;
    private int age;
    
    public Human()
    {
    }
    
    public Human(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
    
    public void setName(String name)
    {
        this.name = name;
    }
    
    public void setAge(int age)
    {
        this.age = age;
    }
    
    public String getInfor()
    {
        String strInf = name + ": " + age;
        return strInf;
    }    
}

class Student extends Human
{
    public String school;
    
    public Student()
    {
    }
    
    public Student(String name, int age, String school)
    {
        super(name, age);
//        this.name = name;  //error 因为name时私有的
//        this.age = age;        //error 同上
        this.school = school;
    }
    
    public void setSchool(String school)
    {
        this.school = school;
    }    
    
    public String getInfor()
    {
        //String strInf = name + ": " + age + ": " + school;  //error 因为age是私有的
        String strInf = super.getInfor() + ": " + school;
        return strInf;
    }
}

public class TestStudent1
{
    public static void main(String[] args)
    {
        Student st1 = new Student("张三", 22, "瑞德");
        System.out.printf("%s
", st1.getInfor());
    }
}

class A
{
    public void f()
    {
        System.out.printf("AAAA
");    
    }
}

class B extends A
{
    public void f()
    {
        System.out.printf("BBBB
");
    }
}

class C extends B
{
    public void f()
    {
        System.out.printf("CCCC
");    
    }    
} 

public class F
{
    public static void g(A aa)
    {
        aa.f();    
    }
    public static void main(String[] args)
    {
        A aa = new A();
        B bb = new B();
        C cc = new C();
        
        g(aa);
        g(bb);
        g(cc);
    }    
}
/*
    多态注意事项
        子类对象可以直接赋给父类引用，但父类对象在任何情况下
        都不可以直接赋给子类引用，因为子类是父类的一种，但父类
        不是子类的一种，或者讲“子类可以当作父类看待，但父类不可以
        当做子类看待”，“狗可以当做动物看待，但动物不可以当做狗来看待”
        
        通过父类引用只能访问子类从父类继承过来的成员
        通过父类引用不能方位子类对象所特有的成员
        父类引用永远不可能直接赋给子类引用
            只有在父类引用本身指向的就是一个子类对象时，才可以把父类引用
            强制转化为子类引用
            
            其他情况下不允许把父类引用强制转化为子类引用，否则运行时会出错
*/

interface It
{
    public abstract void f();    //不能带有方法体（ 抽象类中允许）
}

interface It2 
{
    final int i = 20; // 用final 修饰 表示i 是最后一次赋值
}

final class A implements It,It2  // 用final修饰 表示该类不能再被继承 implements 表示连接接口
{
    
    public void f() //一个类要想实现某接口中的方法时，必须得在方法返回值前加public
    {
        System.out.printf("i = %d",i);    
    }    
}

class F
{
    public static void main(String[] args)
    {
        A aa = new A();
        aa.f();    
    }    
}
/*
    1.  接口中定义的属性必须是public static final的，而接口中定义的方法则必须
    是public abstract的，一次这些修饰符可以部分或全部省略。
    
    2.  接口中定义的属性的值在实现类中不能被更改
    
    3.  参见TestInter_1.java
    
    4.  一个类只能实现某个接口， 不能继承某个接口
    
    5.  但接口可以继承接口
    
    6.  接口不但可以继承接口，而且可以继承多个接口，即接口允许多继承
    
    7.  如果一个类只实现一个接口的部分方法，则该类必须的声明为抽象类
    
    8.  一个类可以在继承一个父类的同时实现一个或多个接口，但extends
    关键字必须的在implements之前
        TestInter_2.java
        
    9.  不可以new接口对象，但可以定义一个接口引用类型的变量，并将其指
    向实现接口的对象，达到多态的目的！
*/

class A
{
    int divide(int a ,int b)
    {
        int m ;
        //System.out.printf("123456");
        m = a/b;
        //System.out.printf("123456");
        return m;    
    }
}

class B
{
    public static void main(String[] args)
    {
        A aa = new A();    
        
        try
        {
            aa.divide(6,0);
        }
        catch(ArithmeticException e) //e用来接收23行抛出的异常对象
        {
            e.printStackTrace(); //可以简单理解为输出该异常的具体信息
            System.out.printf("除零错误，你的程序出错啦！除数不能为零。");
        }
        System.out.printf("是不是啊");
    }    
}