用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包中的类。