java入门的语法学习

用java语言写了一个求两个数最大公约数的程序：

import java.io.*;
import java.util.*;
import java.math.*;

public class Main{
	static int a[] = new int[5];

	static int gcd(int a, int b){
		return b==0?a:gcd(b, a%b);
	}

	public static void main(String []args){
		Scanner reader = new Scanner(System.in);
		int n, m;

		while(reader.hasNext())
		{
			n = reader.nextInt();
			m = reader.nextInt();
			int dd = gcd(n, m);
			System.out.println(dd);
		}
	}
}

java可以进行数组的引用，比如 //b=a，b数组和a数组是相同的地址。 但如果我们要复制数组呢，我们可以用Arrays类的调用方法。

这个是最实用的使用方式：

import java.util.*;

public class myCode {

	public static void main(String[] args) {
        int a[] = {1, 2, 3, 4, 5, 6};
        int b[], c[], d[];
        b = Arrays.copyOf(a, 10);//复制10个元素过来，不够的默认为0
        System.out.println(Arrays.toString(a));

        System.out.println(Arrays.toString(b));

        c = Arrays.copyOfRange(a, 3, 5);// 复制下标3 至 5-1
        System.out.println(Arrays.toString(c));

        d = Arrays.copyOfRange(a, 3, 9);//复制3至8，不够的默认为0
        System.out.println(Arrays.toString(d));

	}
}

/*
输出结果：
   [1, 2, 3, 4, 5, 6]
   [1, 2, 3, 4, 5, 6, 0, 0, 0, 0]
   [4, 5]
   [4, 5, 6, 0, 0, 0]
 */

java中数组的函数排序和函数进行二分查找。

import java.util.*;

public class myCode {

	public static void main(String[] args) {
        int a[] = {11, 2, 13, 44, 105, 86, 77, 32};
        Arrays.sort(a);//数组函数排序
        System.out.println(Arrays.toString(a));

        int key=55;//二分查找55是否存在于a数组
        int index = Arrays.binarySearch(a, key);
        if(index>=0)
        	System.out.println("关键字存在，位置是"+index);
        else
        	System.out.println("index返回值是负数，表示关键字不存在");
	}
}

java switch语句中进行枚举类型值得使用：

import java.util.*;

enum month{
	January, February, March, April, May,
    June, July, August, September,
	October, November, December
}

public class myCode {

	public static void main(String[] args) {
        Scanner reader=new Scanner(System.in);
		month ans=month.January;

        switch(ans){
        case January: System.out.println("1月"); break;
        case February: System.out.println("2月"); break;
        case March: System.out.println("3月"); break;
        case April: System.out.println("4月"); break;
        case May: System.out.println("5月"); break;
        case June: System.out.println("6月"); break;
        default: System.out.println("系统没有匹配到"); break;
        }
	}
}

1.类的定义及使用：

样例代码：

class Main{
	String name;
	int age;
	String sex;
	String address;
	void eat(){
		System.out.println("我会吃饭 ");
	}
	void run(){
		System.out.println("我会跑步  ");
	}
	public static void main(String[] args) {
		Main p;
		p = new Main();
		p.name = "张三";
		p.age=18;
		p.sex="女";
		p.address = "山东淄博";
		System.out.println(p.name+"说：");
        System.out.println("我叫"+p.name );
        System.out.println("性别"+p.sex);
        System.out.println("我今年"+p.age+"岁");
        System.out.println("我住在"+p.address );
        p.eat();
        p.run();
	}
}

也可以这样写：

package java_1;

class person{
	String name;
	int age;
	String sex;
	String address;
	void eat(){
		System.out.println("我会吃饭 ");
	}
	void run(){
		System.out.println("我会跑步  ");
	}
}
public class Main{
	public static void main(String[] args) {
		person p;
		p = new person();
		p.name = "张三";
		p.age=18;
		p.sex="女";
		p.address = "山东淄博";
		System.out.println(p.name+"说：");
        System.out.println("我叫"+p.name );
        System.out.println("性别"+p.sex);
        System.out.println("我今年"+p.age+"岁");
        System.out.println("我住在"+p.address );
        p.eat();
        p.run();
	}
}

//第四章 类与对象
//可变参数：是指在生命方法时，不给出参数列表中从某项直到最后一项的参数的名字和个数
//但这些参数的类型必须相同
public void f(int ... x);
//在这个方法f()的参数列表中，从第一个至最后一个参数都是int类型，
//但连续出现的int类型参数个数不确定，称x是方法f()的参数列表中可变参数的“参数代表”
//也可以这样定义：
public void g(double a, int ... x);
//参数代表可以通过下标运算来代表参数列表中的具体参数，即x[0],x[1],x[2]...x[m]
//分别表示x代表的第1~m个参数（很类似一个不确定长度的数组）
//对于一个参数代表，例如x，x.length等于x所代表的参数的个数

应用：（分到不同的文件中去执行下面的代码）

package java_1;

public class Computer {
	public double getResult(double a, int ... x){
		double result=0D;
		int sum=0;
		for(int i=0; i<x.length; i++){
			sum=sum+x[i];
		}
		result = a*sum;
		return result;
	}
}

public class Main{
	public static void main(String[] args){
		Computer computer=new Computer();
		double result = computer.getResult(1.0/3, 10,20,30);
		System.out.println("10+20+30的平均数:"+result );

		result = computer.getResult(1.0/6, 5,8,9,6,3,66);
		System.out.println("这些数的平均数是："+result );
	}
}

//输出结果：
10+20+30的平均数:20.0
这些数的平均数是：16.166666666666664

//第四章
//4.6 stdtic关键词
//类体的定义包括：成员变量的定义和方法的定义，并且成员变量的定义又分为：实例变量
//和类变量。用static声明的变量就是累变量。同样的，方法的定义除了构造方法外，还
//有实例方法和类方法。

/*
 1.实例方法可以调用该类中的实例方法或类方法
 2.类方法只能调用该类的类方法，不能调用该类的实例方法
 */
//注意：对象共享类变量

下面的代码程序：对static变量的调用 和 static变量的值（分开到不同的文件中！！！）。

package java_1;

public class lader {
	double 上底, 高; //实例变量
	static double bottom; //类变量

	void set上底(double a){
		上底 = a;
	}
	void set下底(double b){
		 bottom = b;
	}
    double get上底(){
    	return 上底;
    }
    double getBottom(){
    	return bottom;
    }
}

public class Main {
	public static void main(String[] args) {
		 lader.bottom = 100;
		 //lader的字节码被加载到内存，通过类名操作类变量
		 lader lader1 = new lader();
		 lader lader2 = new lader();
		 lader1.set上底(28);
		 lader2.set上底(66);
		 System.out.println("lader1的上底和下地:"+lader1.get上底()+"  "+lader1.getBottom() );
		 System.out.println("lader2的上底和下底:"+lader2.get上底()+"  "+lader2.getBottom() );
	}

}

//第四章
//4.8 包
/*
  包是java语言有效管理类的一个机制。
 不同java源文件中可能出现名字相同的类，想要区分开，就需要使用包名
 使用包名的目的是有效的区分开名字相同的类

 package为该源文件声明的类指明包名
 package abc;
 package a.b.c;  //都合法

 */

第5章 继承与接口

面向对象编程 的特点：类的封装  类的继承  类的多态。

5.1节
 *利用继承可以先编写一个具有共同属性的类，然后根据一般类编写具有特殊属性的类。
 * 新类继承一般类的状态和行为，并根据需要增加新的状态和行为。
 * 由继承得到的类成为 子类，被继承的类称为 父类（超类）
 * 特别注意：java不支持多重继承（只能有一个父类，接口机制会弥补这个缺点）
格式：
class 子类名 extends 父类名{
    ......
}

extends关键字包含在Object的类中，Object是java.lang包中的类。