1、输入输出
输出
（1）print()方法：实现不换行的数据输出；
（2）println()方法：与上面方法的差别是输出数据后将换行。
（3）printf()方法：带格式描述的数据输出。JDK1.5新增。
该方法包含两个参数，第1个参数中给出输出格式的描述，第2个参数为输出数据，其中，输出格式描述字符串中需要安排与输出数据对应的格式符。
常用格式符包括：%d代表十进制数；%f代表浮点数；%e代表科学表示法的指数位数；%n代表换行符；%x代表十六进制数；%s代表字符串。 %c 单个字符, %% 输出百分号%
输入
（1）字符类型数据输入
利用标准输入流(System.in)的read()方法，可以从键盘读取字符。但要注意，read()方法从键盘获取的是输入的字符的字节表示形式（返回结果为int类型），需要使用强制转换将其转化为字符型 。
char c=(char)System.in.read();
（2）字符串的输入
实例：
import java.io.*;
public class InputString{
public static void main(String args[]) {
String s="";
System.out.print ("Enter a String please: ");
try {
BufferedReader in= new BufferedReader(
new InputStreamReader(System.in));
s=in.readLine();
}
catch (IOException e) { }
System.out.println ("You've entered a String: " +s);
}
} 数字字符串的转换：
先通过上面的方法获取一个由数字字符组成的字符串，然后通过下面的转换方法转换成需要的数据。
String x="123"；
int m= Integer.parseInt(x); //m 的值为123
x="123.41"；
double n= Double.parseDouble(x) ; //n的值为123.41（3）用Swing对话框输入和显示数据
实例：
import javax.swing.*;
public class Test2{
public static void main(String args[]) {
String s = JOptionPane.showInputDialog("请输入圆的半径：");
double r = Double.parseDouble(s);
double area = Math.PI * r * r;
JOptionPane.showMessageDialog(null, "圆的面积="+area);
}
}（4）使用java.util.Scanner类
Scanner scanner = new Scanner(System.in);
实例：求最大整数
import java.util.Scanner;
public class test{
public static void main(String args[]){
Scanner s=new Scanner(System.in);
System.out.print("请输入3个数，用空格隔开：");
int a= s.nextInt();
int b= s.nextInt();
int c= s.nextInt();
int m = (a > b) ? a : b;
m = (m > c) ? m : c;
System.out.println("最大者="+m);
}
}Math.max(a,Math.max(b,c))
2、流程控制语句
（1）if 语句
if else语句实例：
if (a>b) {
if(a>c)
System.out.println("三个数中最大值是: "+a);
else
System.out.println("三个数中最大值是: "+c);
}
else { //a<=b的情况
if （b>c）
System.out.println("三个数中最大值是: "+b);
else
System.out.println("三个数中最大值是: "+c);
}
else是就近原则！
if else阶梯实例：
public class Ex3_2 {
public static void main(String args[]) {
String str=javax.swing.JOptionPane.showInputDialog("输入学生分数：");
int s= Integer.parseInt(str);
if (s<60)
System.out.println("不及格"); else if (s<70)
System.out.println("及格"); else if (s<80)
System.out.println("中"); else if (s<90)
System.out.println("良");
else
System.out.println("优"); //90分以上
}
} （2）switch
格式：
switch (expression)
{
case value1 : statement1; break; //分支1
case value2 : statement2; break; //分支2
......
case valueN : statementN; break; //分支n
[default : 缺省语句块; ] //分支n+1, 其它
} 
分数段转化为整数值：
import javax.swing.*;
public class Score{
public static void main(String args[]){
int s=Integer.parseInt(JOptionPane.showInputDialog("输入学生分数："));
int x = s/10 ;
switch (x) {
case 0: case 1: case 2: case 3: case 4:
case 5: System.out.println("不及格");break;
case 6: System.out.println("及格");break;
case 7: System.out.println("中");break;
case 8: System.out.println("良");break;
case 9: case 10: System.out.println("优");
}
}
}（3）循环语句
1、while语句
while (条件表达式) {
循环体
} 特点:先判断后执行
实例：在三位数中找出所有水仙花数，水仙花数的条件是该数等于其各位数字的立方和。
public class Narcissus {
public static void main(String arge[]) {
int i, j, k, n=100, m=1;
while (n<1000) {
i = n/100; //获取最高位
j = (n-i*100)/10; //获取第2位
k = n%10; //获取最低位
if (Math.pow(i,3)+Math.pow(j,3)+Math.pow(k,3)==n)
System.out.println("找到第 "+ m++ +" 个水仙花数："+n);
n++;
}
}
}
实例：从键盘输入一个长整数，求其各位数字之和。
public class Ex3_4{
public static void main (String args[]) {
long a,n,m=0;
a= Long.parseLong(
JOptionPane.showInputDialog("输入整数"));
n=a;
while(n>0) {
m += n%10; //累加计算各位数字
n = n/10;
}
System.out.print(a+"的各位数字之和="+m);
}
}
2、do...while语句
do
{
循环体
} while (条件表达式); 特点：先执行，后判断
实例：用迭代法求某数a的平方根
import java.util.*;
public class FindRoot {
public static void main(String args[ ]) {
double x1, x2, a;
System.out.print("请输入a=? ");
Scanner scan=new Scanner(System.in);
a = scan.nextDouble();
x1 = a / 2; //设置解初值
do
{
x2 = x1; //记住上一个解
x1 = (x2 + a / x2) / 2; //求下一个解
} while (Math.abs(x1 - x2) >= 1e-5); //迭代结束条件
System.out.printf("%f的平方根是%.5f\n", a,x1);
}
}3、for语句
for (控制变量设定初值；
循环进行条件；迭代部分)
循环体
说明：
1、
初始化、循环条件以及迭代部分都可以为空语句(但分号不能省)，三者均为空的时候，相当于一个无限循环。
for (;;) System.out.println("hello");
例如，求长整数的各位数字之和改用for循环
long a，n,m=0;
n=a= Long.parseLong(
JOptionPane.showInputDialog("输入整数"));
for ( ; a>0; a = a/10) {
m += a%10; //累加计算各位数字
}
System.out.print(n+"的各位数字之和="+m);
2、
在初始化部分和迭代部分可以使用逗号语句，来进行多个操作。所谓逗号语句是用逗号分隔的语句序列。例如：
for( int i=0, j=10; i<j; i++, j-- ) {
System.out.println(i+", "+j);
}
实例：
public class Ex3_6{
public static void main(String args[ ]) {
double sum = 1,term=1;
int flag = 1;
for ( int n = 2; n <= 20; n++) {
flag = - flag;
term *= 1.0/n;
sum += flag * term;
}
System.out.println("sum = " + sum);
}
}实例：利用随机函数产生10道2位数的加法测试。
import javax.swing.*;
public class Ex3_7 {
public static void main(String args[]){
int score = 0;
for (int i=0;i<10;i++) {
int a = 10 + (int)(90*Math.random());
int b = 10 + (int)(90*Math.random());
String s=JOptionPane.showInputDialog(a+"+"+b+"=? ");
int ans = Integer.parseInt(s);
if (a + b == ans)
score = score + 10 ; //每道题10分
}
JOptionPane.showMessageDialog(null, "your score= "+score);
}
}循环镶套：
与条件语句的嵌套类似，循环也可以嵌套。三种循环语句可以自身嵌套，也可以相互嵌套。嵌套将循环分为内外两层，外层循环每循环一次，内循环要执行一圈 。
实例：输出9x9的乘法表
for (int i=1;i<=9;i++) {
for (int j=1;j<=9;j++)
System.out.print(i+"*"+j+"="+i*j+"\t");
System.out.println();
}
实例：找3-50之间的素数
for (int n=3;n<=50;n++) { //外循环
boolean f=true; int k=2;
while (f && k<=(n-1)) { //内循环,从2～(n-1)去除n
if (n % k==0)
f=false; //发现有一个数能除尽n就不是素数
k++;
}
if (f) {
System.out.print("\t"+n);
m++; //统计找到的素数个数
if (m%5==0)
System.out.println();
}
}
（4）跳转语句
1、break语句：
不带标号,从break直接所处的循环体中跳转出来。
带标号, 跳出标号所指的代码块，执行块后的下一条语句。
实例：四位同学中一位做了好事，班主任问这四位是谁做的好事。A说“不是我”；B说“是C”。C说“是D”；D说“C胡说”。已知有3人说真话.
public class Good{
public static void main(String args[]) {
char man;
for (man = 'A'; man <= 'D'; man++) {
int a = (man != 'A') ? 1 : 0;
int b = (man == 'C') ? 1 : 0;
int c = (man == 'D') ? 1 : 0;
int d = (man != 'D') ? 1 : 0 ;
if (a + b + c + d == 3)
break;
}
System.out.println("the man is "+man);
}
}
2、continue语句：
有两种形式：
continue 标号名 ：带标号, 跳转到标号指明的外层循环中
实例：输出10～20之间不能被3或5整除的数
public class ContinueTest {
public static void main(String args[]) {
int j=9;
do {
j++;
if(j%3==0||j%5==0) continue;
System.out.print(j + " ");
} while(j<20);
}
}
思考：
for(;;) { … } 是什么意思？
3、数组和方法
（1）数组
数组是程序设计语言中常用的一种数据组织方式，数组广泛应用于批量数据的处理。
数组的主要特点如下:
3每个数组元素用数组名和位置（称为下标）表达。
1、一维数组
一维数组与数学上的数列有着很大的相似性。
数列：a1,a2,a3,a4,….a10
创建一维数组需要以下三个步骤:
1. 声明数组:
格式1： 数组元素类型 数组名[] ;
格式2： 数组元素类型[] 数组名 ;
其中，数组元素的类型可以是基本类型，也可以是类或接口。
例如，要保存某批学生的成绩，可以定义一个数组score,声明如下：int score[];
或者 int [] score;
2. 创建数组空间 :
数组名 = new 数组元素类型 [元素个数]; 
例如，score = new int[10];
在声明数组的同时给数组规定空间，两步合并。
例如：int score [ ] = new int[10];
反例：
3. 创建数组元素并初始化 ：
格式如下：
例如：
int score[ ] = {1,2,3,4,5,6,7,8,9,10};
int score[ ]=new int[ ] {1,2,3,4,5,6,7,8,9,10};
score.length 指明数组score的长度。
实例：求10个学生的平均成绩（10名学生只要该数组大小）
public class Ex4_1 {
public static void main(String args[]) {
int score[ ] = new int[10];
for (int k = 0; k < score.length; k++) {
score[k] = (int) (Math.random( ) * 101);
System.out.print(score[k] + "\t");
}
System.out.println( );
/* 以下计算输出平均成绩 */
int sum=0;
for (int k=0; k<score.length ;k++)
sum+=score[k];
System.out.println("平均成绩为：" +sum/score.length);
}
} 
实例：
class test3{
public static void main(String args[ ]){
int a[]={1,2,3,4};
for (int i=0;i<4;i++)
a[i]=a[i]+i;
for(int b:a)
System.out.println(b);
}
} 
实例：利用随机数模拟投掷色子500次,输出各个数的出现次数
public class Ex4_2 {
public static void main(String args[]) {
int count[] = new int[6];
for ( int k = 0; k<500; k++){ // 投掷500次
int v = (int)(Math.random()*6+1);
count[ v-1 ]++; //对应色子点值计数增加1
}
for (int i = 0;i<count.length; i++)
System.out.println( (i+1)+
"出现次数为: "+count[i]);
}
}
实例：将一维数组元素按由小到大排列
public class TestSort{
public static void main(String args[ ]) {
int a[ ] = {4,6,3,8,5,3,7,1,9,2};
int n= a.length;
System.out.println("排序前…");
for (int k=0;k<n;k++)
System.out.print(" " + a[k]);
System.out.println();
for (int i=0; i<n -1; i++)
for (int j=i+1;j<n;j++)
if (a[i]>a[j]) {
/* 交换a[i]和a[j] */
int temp=a[i];
a[i]=a[j];
a[j]=temp;
}
System.out.println("排序后…");
for (int k=0;k<n;k++)
System.out.print(" " + a[k]);
}
}
2、二维数组
1. 二维数组声明：
格式1：数组元素类型 数组名[ ][ ];
格式2：数组元素类型[ ][ ] 数组名;
例如：int a[][];
2. 创建二维数组空间：
二维数组看作是数组的数组，不要求二维数组每一维的大小相同
（1）直接为每一维分配空间，如：
int a[][] = new int [2][3];
（2）从最高维开始，按由高到低的顺序分别为每一维分配空间。如：
int a[][] = new int [2][];
a[0] = new int [3];
a[1] = new int [4];
二维数组中求数组长度：
数组名.length
数组名[行标].length
实例：二维数组动态创建示例 
public class ArrayOfArraysDemo2 {
public static void main(String[] args) {
int[][] aMatrix = new int[4][];
for (int i = 0; i < aMatrix.length; i++) {
aMatrix[i] = new int[i+1];
for (int j = 0; j < aMatrix[i].length; j++)
aMatrix[i][j] = i + j;
}
for (int i = 0; i < aMatrix.length; i++) {
for (int j = 0; j < aMatrix[i].length; j++)
System.out.print(aMatrix[i][j] + " ");
System.out.println();
}
}
} 3. 创建数组元素并初始化
int a[][] = {{1,2,3},{4,5,6}};
int b[][] = {{1,2},{4,5,6}};
实例：求矩阵的最外一圈元素之和
public class Demo {
public static void main(String[ ] args) {
int [ ][ ] a = new int[4][5];
int sum=0;
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
a [i][j] = (int)(Math.random()*10);
System.out.print(a[i][j] + "\t");
if (i==0||j==0||i==a.length-1||j==a[0].length-1)
sum += a[i][j];
}
System.out.println();
}
System.out.println("sum= " +sum);
}
}
（2）方法
方法是类的行为属性，标志了类所具有的功能和操作。由方法头和方法体组成
1、方法声明
修饰符1 修饰符2 ... 返回值类型 方法名(形参表) //形参表格式如下: 类型1 参数名 1, 类型2 参数名2,... ； 方法头定义方法的访问形态
{
方法体各语句 ; //方法体给出方法的具体实现
} //有返回值类型的方法必须有return语句
return返回值必须与方法头定义的返回值类型相匹配
实例：求阶乘的方法
/* 求n!的方法fac(n) */
public static long fac(int n) { //方法头
long res=1; //放
for (int k=2;k<=n;k++) //法
res = res * k;
return res; //体
}
调用方法只需关注方法头！ 方法定义时要说明每个参数的类型
2、方法调用
形式：方法名（实参表）实参的个数、类型、顺序要与形参对应匹配。
例：public static long fac(int n)
实例：编写求阶乘的方法，并利用求阶乘的方法实现一个求组合的方法,利用求组合方法计算输出杨辉三角形。
public class Ex4_5{
/* 求n!的方法fac(n) */
public static long fac(int n) {
long res=1;
for (int k=2;k<=n;k++)
res = res * k;
return res;
}
/* 求n个中取m个的组合方法 */
public static long com(int n , int m) {
return fac(n) / (fac(n-m) * fac(m) );
}
public static void main(String args[ ]) {
for (int n=0;n<=3;n++) {
for (int m=0;m<=n;m++)
System.out.print( c (n, m) +" ");
System.out.println( );
}
}
}
3、参数传递
Java方法参数传递是以传值的方式进行，实参值传递给形参。
数据类型分基本类型和引用类型。
1. 基本类型参数传递
基本数据类型实参单元存储的是变量值，是将实参数据传递给形参; 在方法内对形参的修改不影响实参。
实例：基本类型参数传递演示
public class Test1{
static void paraPass(int x) {
x = x+1;
System.out.println("x= "+x);
}
public static void main(String args[]) {
int m=5;
paraPass(m);
System.out.println("m= "+m);
}
} 
2. 引用类型参数传递
引用类型（如对象、数组等）参数, 实参单元存储的是地址，是将对象引用地址传递给形参。方法内通过形参访问的就是实参的对象。
实例： 引用类型的参数传递
public class Test2 {
static void paraRef(int x[ ]) {
x[1]=x[1]+1;
}
public static void main(String args[]) {
int a[ ] = { 1 , 4 , 6 , 3 };
paraRef(a);
for (int k=0;k<a.length;k++)
System.out.print (a[k]+ "\t");
}
}
4、递归
static int fac (int n) {
if (n==1)
return 1;
else
return n*fac(n-1);
}
5、Java方法的可变长参数
标准输出流的printf方法：
printf(String format,Object ...obj)
方法调用：
System.out.printf("%d ",n); //其中,n为整形变量
System.out.printf("%d %s",n,"cat");
注意：可变长参数必须处于方法参数排列中的最后位置.
可变长参数与数组：
static double add(double... parms) { //累加函数
double s = 0;
for (double p : parms) //参数在方法内当数组用
s += p;
return s;
}
针对该方法的以下调用均是成立的。
double sum1 = add(1.8, 6 ,6.4 , 8.2);
double sum3 = add();
特别地,如果实参数据来自数组,则可直接传递数组名。例如:
double[] score = {90, 80, 65,70,59};
double sum = add(score);
（3）Java的命令行参数
实例：输出命令行所有参数
public class AllCommandPara {
public static void main( String[] args ) {
for(int i=0;i<args.length;i++)
System.out.println(args[i] + " ");
}
}D:\>java AllCommandPara "hello good" 34 "my 123" //空格作为参数间分隔符
（4）Arrays类
Arrays类封装了对数组进行操作的一系列静态方法。
例如：
java.util.Arrays.sort(a) ;
4、类与对象
1 类的定义
扫一扫
6396
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
