黑马训练营java学习日记——二维数组和面向对象（一）
------- android培训、java培训、期待与您交流！ ----------
一、 二维数组
数组：存储同一种数据类型的多个元素的容器。
这里的元素可以是8中基本数据类型，也可以是引用类型。
因此，这个数组中的元素也可以是一个数组，这样就形成了二维数组
1、 二维数组的格式
（1） int[][] arr = new int[3][2];
定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有2个元素
一维数组的名称分别为arr[0],arr[1],arr[2]
给第一个一维数组1角标赋值为32写法是：arr[0][1] = 32;
（2） int[][] arr = new int[3][];
二维数组中有3个一维数组
每一个一维数组都有默认初始化值null
注意：第一维的长度必须给出
可以对这三个一维数组进行初始化
arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];
（3） int[][] arr = {{3,8,2},{2,7},{9,0,1,6}}
定义一个名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中具体元素也都被初始化
第一个一维数组arr[0] = {3,8,2};
第二个一维数组arr[1] = {2,7};
第三个一维数组arr[2] = {9,0,1,6};
第三个一维数组的长度表示为arr[2].length
注意：特殊写法情况：int[] x,y[]; 其中x是一维数组，y是二维数组。
二维数组练习：
需求：对二维数组进行遍历。
class Array2Test
{
public static void main(String[] args)
{
//顶一个个二维数组
int[][] arr = {{2,4,7,3},{5,6,4},{5,0,2,1,4}};
for (int x=0;x需求：
一年有四个季节，每个季节三个月。
某公司的销售额如下：
第一个月 第二个月 第三个月
春：100 50 300
夏：500 400 0
秋：600 350 100
冬：0 200 0
要求：请用二维数组表示我的数据，并计算一年的销售额。
/*
分析：
A：将数据用二维数组包装起来
B：对二维数组进行遍历，获取每一个元素
C：对每个元素进行累加。在开始处定义一个累加变量
D：累加后的结果就是我们想要的总金额
*/
class Array2Test2
{
public static void main(String[] args)
{
//将数据用二维数组包装起来
int[][] arr = {{100,50,300},{500,400},{600,350,100},{0,200}};
int sum = 0;//定义累加变量
for (int x=0;x二、 数组综合应用：
题目：
某个公司采用公用电话传递数据信息，数据是小于8位的整数，为了确保安全，在传递过程中需要加密，加密规则如下：
首先将数据倒序，然后将每位数字都加上5，再用和除以10的余数代替该数字，最后将第一位和最后一位数字交换。
请任意给定一个小于8位的整数，然后，把加密后的结果在控制台打印出来。
class JiaMi
{
public static void main(String[] args)
{
int num = 123456;//要传递的信息
int[] arr = new int[8];//定义一个数组，用于装信息的每一位数据
int index = 0;//定义索引值并初始化
/*
for (;num>0 ;num/=10 )
{
arr[index] = num%10;
index++;
}
*/
while (num>0)//判断信息值是否大于0并作为循环条件
{
arr[index] = num%10;//获取信息的个位数并装入数组
num/=10;//将个位数装入数组后去掉原信息值的个位
index++;//索引值加1
}
syso(arr,index);//调用打印方法，查看结果是否正确
for (int x=0;x三、 面向对象（一）
面向对象设计实质上就是对现实世界的对象进行建模操作。
对象：分为两个部分，即：静态部分和动态部分。静态部分，顾名思义就是不能动的部分，这个部分被称为“属性”，如：一个人，包括高矮、胖瘦、性别、年龄等属性。动态部分，如，这个人可以行走、微笑、说话、哭泣等，这些就是这个人具备的行为（动态部分）。
类：实质上就是封装对象属性和行为的载体，而对象则是类抽象出来的一个实例。
1、面向对象基本知识
(1)面向对象：是一种编程思想。
A:它是相对于面向过程而言的。
a:面向过程强调的是过程
b:面向对象强调的是对象调用功能，看最终的结果
B:它是基于面向过程的。
(2)面向对象的特点：
A:是一种符合人们思考习惯的一种思想。
B:把复杂的事情简单化了。
C:是我们从以前的执行者变成了现在的指挥者。
(3)类与对象的关系
A:类和对象分别是什么？
a:类 是对同一类事物的抽象
b:对象 是该类事物的具体的存在的个体
B:java是怎么来描述现实世界事物的？
a:现实世界的事物可以通过属性和行为来描述
b:java对现实世界的事物是通过类来体现的
c:java中的成员和现实世界事物的对应关系：
成员变量：属性
成员方法：行为
2、成员变量和局部变量
区别：
A:位置不同：
成员变量定义在类中，方法外。
局部变量定义在方法中。
B:生命周期：
成员变量是随着对象的创建而存在，在堆内存，随着对象的消失而消失。
局部变量是随着方法的调用或者语句的执行而存在，在栈内存，随着方法的调用完毕或者语句执行完毕而消失。
C:初始化值：
成员变量都有默认初始化值
局部变量没有默认初始化值,要想使用：必须是创建，赋值，使用。
使用变量的原则：就近原则。
class Car//对Car这类事物进行描述
{
String color = "red";
int num = 4;
void show()
{
System.out.println("color="+color+"..num="+num);
}
}
class CarDemo
{
public static void main(String[] args)
{
Car c = new Car();//建立对象
c.color = "black";//对对象的属性进行修改
c.show();//使用对象的功能。
}
}
对象的内存结构：
只要是用new操作符定义的实体就在会堆内存中开辟一个新的空间。
并每一个对象中都有一份属于自己的属性。
通过 对象.对象成员 的方式操作对象中的成员，
对其中一个对象的成员进行了修改。和另一个对象没有关系。
3、匿名对象：
定义：
匿名对象就是没有名字的对象，是对象的简化形式。
使用场景：
A：当对对象方法仅进行一次调用的时候
主要原因：匿名对象使用完毕，对象就是垃圾了，可以在JVM空闲的时候被回收
B：匿名对象可以作为实际参数进行传递
class Demo
{
public void show()
{
System.out.println("上课了");
}
public void play()
{
System.out.println("玩我们自己编写的游戏");
}
public void method(Demo d) //Demo d = new Demo();
{
d.show();
d.play();
}
}
class NiMingDemo
{
public static void main(String[] args)
{
//创建对象
Demo d = new Demo(); //创建一个对象
//d.show();//调用show方法
//d.play();//调用play方法
//d.method(d);//调用method方法并将自己这个对象作为参数传递
//使用匿名对象来调用方法
new Demo().show(); //创建了一个对象,调用方法
new Demo().play(); //又创建了一个对象,调用方法
Demo d2 = new Demo();
d2.method(d);
d2.method(new Demo());//将匿名对象作为参数传递
}
}
为什么要使用匿名对象？（面试）
答：匿名对象使用完毕后，因为没有栈内存的指向，所以本身就是垃圾了，可以在JVM空闲的时候被垃圾回收机制回收。
4、 封装(Encapsulation)（面向对象的特点之一）
(1) 概念：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式
(2) 好处：
①将变化隔离
②便于使用
③提高复用性
④提高安全性
举例：电脑机箱
(3) 封装原则：
①将不需要对外提供的内容都隐藏起来
②把属性都隐藏，提供公共方法对其访问
(4) 封装在java中的体现：
Java中的类和方法都是封装的体现
(5) 用private私有关键字体现：
A：是一个权限修饰符
B：用于修饰成员（成员变量和成员方法）
C：被私有化的成员值在本类中有效
将成员变量私有化，对外提供对应的set，get方法对其进行访问，提高对数据访问的安全性
代码体现：
class Student
{
String name;
private int age;
public void hello()
{
age = 20;
}
public void hello(int a)
{
//加入条件判断
if(a<0 || a>100)
{
System.out.println("年龄输入有误");
}
else
{
//正常数据就赋值成功
age = a;
}
}
public void show()
{
System.out.println("学生的年龄："+age);
}
/*
public static void main(String[] args)
{
Student s = new Student();
System.out.println(s.age);
}
*/
}
class StudentDemo
{
public static void main(String[] args)
{
Student s = new Student();
//赋值
//s.age = 20;
//输出
//System.out.println(s.age);
//s.hello();
//我不可能每个学生的年龄都是20
//我们可以把年龄作为参数传递：a
s.hello(20);
//s.hello(-20);
//使用方法
s.show();
}
}
5、 构造方法
(1)用于创建对象的方法。
多个构造方法是以重载的形式出现的
(2)特点：
A:构造方法的名称和类名相同
B:不定义返回值类型
C:没有返回值
格式：
修饰符 类名(参数)
{
//code
}
(3)构造方法的特点：
A:如果一个类没有写构造方法，系统会默认给出一个无参构造方法。
B:如果一个类写了构造方法，系统都不会再给出默认构造方法。
这个时候，如果你想要使用无参构造方法，自己写。
推荐：任何一个非测试类，都给出无参构造方法。
C:构造方法还可以给成员变量赋值
(4) 构造方法和成员方法的区别？
A:作用
构造方法：用于创建对象，并进行初始化值。
成员方法：完成特定功能的代码。
B:调用
构造方法：在创建对象的时候被调用。
成员方法：使用对象调用。
代码体现：
class Student
{
private String name;
//没有修饰符的时候，是默认修饰符
/*
Student()
{
System.out.println("真的是调用我了吗");
}
*/
public Student()
{
System.out.println("name:"+name);
name = "hello";
System.out.println("name:"+name);
}
public Student() //"刘先生"
{
System.out.println("name:"+name); //null
name = n; //"刘先生"
System.out.println("name:"+name); //"刘先生"
}
public void show()
{
System.out.println("我爱上晚自习");
}
}
class ConstructorDemo
{
public static void main(String[] args)
{
//使用默认的构造方法
Student s = new Student();
//通过对象调用方法
//s.show();
//使用带参数的构造方法
Student s2 = new Student("刘先生");
s2.show();
}
}
6、 this关键字
(1) 特点：this代表其所在函数所属对象的引用，也就是说，this代表本类对象的引用。
谁调用，this就代表谁。
(2) this的使用场景
①避免局部变量隐藏成员变量
public Student(String name,int age)
{
this.name = name;
this.age = age;
}
public void setName(String name)
{
this.name = name;
}
代码示例：
class Student
{
private String name;
private int age;
public Student(){}
/*
public Student(String n,int a)
{
name = n;
age = a;
}
*/
//n,a这样的变量没有意义，不建议使用。最好使用name,age。
public Student(String name,int age) //"凤姐",18
{
//变量的使用原则：就近原则
//本身赋值给本身 name = name;
//name = name;
//age = age;
//Student.name = name;
this.name = name;
this.age = age;
}
//getXxx()/setXxx()省略
public void show()
{
System.out.println(name+"***"+age);
}
public void setAge(int age)
{
//age = age;
this.age = age;
}
public int getAge()
{
//int age = 30;
//return this.age;
return age; //省略了this。可以认为前面有一个this关键字。
}
}
class ThisDemo
{
public static void main(String[] args)
{
//调用无参构造方法创建对象
Student s = new Student();
s.setAge(20);
System.out.println("age:"+s.getAge());
s.show(); //null***0
//调用带参构造方法
Student s2 = new Student("刘",18);
s2.show();
}
}
②在方法内部有一个this对象，哪个对象调用，this代表谁。
举例：比较两个学生的年龄
class Student
{
private String name;
private int age;
public Student(){}
public Student(String name,int age)
{
this.name = name;
this.age = age;
}
public void setName(String name)
{
this.name = name;
}
public String getName()
{
return name; //这里的this一般省略
}
public void setAge(int age)
{
this.age = age;
}
public int getAge()
{
return age;
}
/*
明确：
返回值类型：boolean
参数列表：两个学生的年龄,int age1,int age2
*/
/*
public boolean compare(int age1,int age2)
{
return age1==age2; //它本身就是一个boolean值
}
*/
//面向对象的语言，所以，尽可能的把参数作为对象传递。
/*
public boolean compare(Student s1,Student s2)
{
//return s1.getAge() == s2.getAge();
return s1.age == s2.age;
}
*/
public boolean compare(Student s) //s2
{
//问题来了，这个时候，我们只看到了一个对象。
//那么，还差一个对象在哪里？this
//也就是说：this代表s1，s代表s2
//return s1.age == s2.age;
return this.age == s.age;
}
}
class ThisDemo2
{
public static void main(String[] args)
{
//创建了两个学生，并且给出了年龄
Student s1 = new Student();
s1.setAge(20);
Student s2 = new Student();
s2.setAge(30);
//做比较
//boolean flag = s1.compare(s1.getAge(),s2.getAge());
//boolean flag = s1.compare(s1,s2);
//这里的s1相当于使用了2次。
//对象.调用方法()
//这个时候，已经有一个对象了，你只需要在传递一个对象就可以了。
boolean flag = s1.compare(s2);
System.out.println("flag:"+flag);
}
}
③this在构造方法中的使用
this(参数):表示调用构造方法，调用哪个根据参数决定。
注意：在构造方法的第一条语句使用。
代码示例：
class Student
{
private String name;
private int age;
public Student()
{
}
public Student(String name) //this(name); //刘
{
this.name = name; //刘
}
public Student(int age)
{
this.age = age;
}
public Student(String name,int age) //new Student("刘",20);
{
this.name = name;
//简化书写
//this(name); //刘//必须写在第一条语句上
this.age = age;
//this(age);//前边写了this(参数)后边就不能再写了
}
public void setName(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
public void setAge(int age)
{
this.age = age;
}
public int getAge()
{
return age;
}
}
class ThisDemo3
{
public static void main(String[] args)
{
Student s = new Student("刘",20);
System.out.println(s.getName()+"***"+s.getAge());
}
}
7、 代码块
(1) 用{}括起来的代码，就叫代码块
(2) 分类：
①局部代码块：可以控制局部变量的生命周期
②构造代码块：
在类中，方法外，用{}扩起来的代码块被称为构造代码块。
每个构造方法调用前都会去调用
代码示例：
class Person
{
//构造代码块
{
System.out.println("哇哇的哭");
}
public Person()
{
//初始化代码
//System.out.println("哇哇的哭");
//cry();
}
public Person(int age)
{
//System.out.println("哇哇的哭");
//cry();
System.out.println(age);
}
//构造代码块
{
System.out.println("哈哈的笑");
}
//写个功能
/*
public void cry()
{
System.out.println("哇哇的哭");
//code.......
}
*/
}
class BlockDemo
{
public static void main(String[] args)
{
System.out.println("Hello World!");
int y = 20;
//局部代码块
{
int x = 10;
System.out.println("真的吗"+x);
}
//System.out.println("真的吗"+x);//不会访问到x的值
Person p = new Person();
Person p2 = new Person(100);
}
}
(3) 静态代码块,构造代码块,构造方法的执行顺序及特点：
静态代码块 > 构造代码块 > 构造方法
静态代码块只执行一次。
构造代码块，每次调用构造方法前都执行一次。
构造方法用于创建对象。
class Person
{
Static//静态代码块
{
System.out.println("哈尼,亲,你好");
}
{//构造代码块
System.out.println("欢迎来到人间");
}
public Person()//构造方法
{
System.out.println("我也很高兴");
}
Static//静态代码块
{
System.out.println("哈尼,亲,你好2");
}
{//构造代码块
System.out.println("欢迎来到人间2");
}
}
class BlockDemo
{
public static void main(String[] args)
{
Person p = new Person();
System.out.println("****************");
Person p2 = new Person();
}
}
8、 static(静态)关键字
(1)static：是一个关键字，可以用于修饰成员(成员变量和成员方法)
(2)特点：
A:随着类的加载而加载
B:优先于对象的存在而存在
C:可以直接使用类名访问
D:被所有的对象共享
(3)静态使用的注意事项：
A:静态只能访问静态成员,非静态可以访问静态也可以访问非静态成员。
非静态方法访问：
非静态变量 OK
静态变量 OK
非静态方法 OK
静态方法 OK
静态方法访问：
非静态变量 NO
静态变量 OK
非静态方法 No
静态方法 OK
B:静态方法中没有this,super关键字。
this,super是创建对象的时候才存在的，而静态是随着类的加载而加载。
C:主方法是静态的。
public static void main(String[] args)
{
}
public：公共的意思，jvm调用，所以，需要访问权限足够大。
static：不需要创建对象就可以使用。jvm是通过MainDemo.main(...)调用
void：jvm调用了main方法，如果有返回值那就是给了jvm了。它要值没用。所以不用返回值。
main：jvm只识别main方法。
参数：
String[] args 字符串数组变量 args
最开是提供这样的参数是有意义的。意义在于，可以接受键盘数据。
(4)静态成员和非静态成员的区别：
A:静态成员是跟类相关的，也被称为类变量。可以被类名直接访问，也可以被对象访问。
建议使用类名访问。
非静态成员是跟对象相关的，所以，被称为成员变量，实例变量。被对象调用。
没有被静态修饰的成员，要想被访问，必须创建对象访问。而现在，被静态修饰后，可以通过对象访问，也可以通过类名访问。
建议，静态修饰全部使用类名访问。
B:静态成员随着类的加载而加载，也就意味着随着类的消失而消失。生命周期长。
非静态成员是创建对象才存在的，随着对象的消失而消失。
C:静态成员存储在方法区中的静态区。
非静态成员存储在对象所属堆内存。
D:静态修饰的是类的所有对象的共享数据。
非静态修饰的是对象的特有数据。
(5)什么时候使用静态呢？
A:根据实际情况分析，如果是被所有对象共享的数据，就用静态修饰。
B:如果成员方法没有访问过对象的特有数据，这个方法就可以定义为静态的。
代码示例：
class Student
{
String name = "杨幂";
static String country = "中国";
//public Student(){}
public void show()
{
//System.out.println("name:"+name);
System.out.println("country:"+country);
//show2();
show3();
}
public void show2()
{
System.out.println("show2");
}
public static void show3()
{
System.out.println("show3");
}
public static void show4()
{
//System.out.println("name:"+name);
System.out.println("country:"+country);
//show2();
//show3();
//System.out.println(this.country);
}
}
class StaticDemo3
{
public static void main(String[] args)
{
//创建对象
Student s = new Student();
s.show();
//s.show4();
Student.show4();
}
9、 制作帮助文档
我们可以定义一个工具类，方便以后使用。
在此我们定义一个数组操作的工具类。
工具类中的方法一般都是完成一个功能的，没有去访问类的特有成员，所以直接使用静态修饰。
制作帮助文档用到了JDK的bin目录下的一个工具，javadoc。
在制作过程中可能会出现一个问题：找不到可以文档化的公共或受保护的类，
原因是类的访问权限不够大，那么就加public权限。
API:Application Programming Interface 应用程序编程接口。也就是说明书。
帮助文档的制作过程：
首先写一个java文件。
把其中的内容加上文档注释。
用javadoc命令解析：
javadoc -d 目录 -version -author 文件名
解释：
javadoc 是javadoc命令
-d 后面跟的是文档将来存储的目录
目录 就是写一个路径名称。例如：c:\\test, doc
-version,-author是把文件中的version和author进行解析
文件名 就是加入了文档注释的类文件的名称
/**
* 这是操作数组的工具类
*
* @author itcast
* @version V1.0
*/
public class ArrayTools
{
/**
* 这是一个成员变量
*/
public static int x = 10;
//为了不让外界创建对象
/**
*不让外界创建对象
*/
private ArrayTools(){}
/*
public ArrayTools(int x)
{
this.x = x;
}
*/
/**
*遍历数组。格式：元素1,元素2,...
*@param arr 表示这是要传递一个数组变量
*/
public static void printArray(int[] arr)
{
//遍历数组
for(int x=0; xmax)
{
max = arr[x];
}
}
//返回参照物,它保留的就是数组中的最大值
return max;
}
/**
*对数组进行排序
*@param arr 表示这是要传递一个数组变量
*/
public static void bubbleSort(int[] arr)
{
for(int x=0; xarr[y+1])
{
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}
}
10、 单利设计模式（重点）
设计模式：
把一些重复的工作，给抽取出来，形成一个模型。以后，做类似的事情，按照这个模型就可以了。
(1)单例设计模式：保证类在内存中只有一个对象。
(2)实现的思路：
A:外界不能创建对象
B:本类创建一个对象
C:提供公共的访问方式
(1) 实现方法：
A：把构造方法私有化
B：在类中new一个对象
C：对外提供一个public类型的方法访问
饿汉式：
class Student
{
//把构造给私有化
private Student(){}
//本身创建一个对象
//静态只能访问静态
//让外界不能通过静态访问，所以改变修饰符
private static Student s = new Student(); //成员变量
//int x = 10;
//为了让外界访问，并且外界还不能创建对象，用static修饰
public static Student getStudent()
{
return s;
}
public void show()
{
System.out.println("show");
}
}
class SingletonDemo//测试类
{
public static void main(String[] args)
{
//不是单例
//Student s = new Student(); //创建了一个对象,内存中有一个地址值
//Student s2 = new Student();//创建了一个对象,内存中有一个地址值
//System.out.println(s==s2); //两个对象类型的变量用==比较，比的是地址值
//是单例
Student s1 = Student.getStudent();
Student s2 = Student.getStudent();
System.out.println(s1==s2);
s1.show();
s2.show();
}
}
懒汉式：
class Student
{
//为了不让外界创建对象
private Student(){}
//这个时候，不去创建对象
private static Student s = null; //s = new Student();
public static Student getStudent()
{
//只在第一次访问的时候，创建一次。
if(s==null)
{
s = new Student();
}
return s;
}
public void show()
{
System.out.println("show");
}
}
class SingletonDemo2 //测试类
{
public static void main(String[] args)
{
Student s1 = Student.getStudent();
Student s2 = Student.getStudent();
System.out.println(s1==s2);
s1.show();
s2.show();
}
}
单利设计模式的完整代码：
饿汉式：
class Student
{
private Student(){}
private static Student s = new Student();
public static Student getStudent()
{
return s;
}
}
懒汉式：
class Student
{
private Student(){}
private static Student s = null;
public static Student getStudent()
{
if(s==null)
{
s = new Student();
}
return s;
}
}
11、 Math类
(1)Math类用于数学运算
(2)Math类的特点：
没有构造方法，成员都是静态的。
(3)能用到的主要的方法：
成员变量：(属性,字段)
PI 圆周率
E 自然对数的底数
成员方法：
abs 绝对值
ceil(double a) 返回的是大于等于参数的最小整数
floor(double a) 返回的是小于等于参数的最大整数
max 返回两个数中较大的值
min 返回两个数中较小的值
pow(double a,double b) 返回第一个参数的第二个参数的次幂
random 随机数，[0.0,1.0) 包含左边,不包含右边
round 四舍五入取值
sqrt 返回数据的平方根
代码示例：
class MathDemo
{
public static void main(String[] args)
{
//成员变量
System.out.println("PI:"+Math.PI);
System.out.println("E:"+Math.E);
//成员方法
System.out.println("abs:"+Math.abs(-12)); //12//求绝对值
System.out.println("ceil:"+Math.ceil(12.56)); //13//返回大于等于参数的最小整数
System.out.println("ceil:"+Math.ceil(-12.56));//-12
System.out.println("floor:"+Math.floor(12.56));//12//返回小于等于参数的最大整数
System.out.println("floor:"+Math.floor(-12.56));//-13
System.out.println("max:"+Math.max(12,23));//求两个参数中较大的一个
System.out.println("min:"+Math.min(12,23)); //求两个参数中较小的一个
//比较三个数的最大值
System.out.println("max:"+Math.max(Math.max(12,23),17));
System.out.println("pow:"+Math.pow(2,4));//返回第一个参数的第二个参数次幂
System.out.println("sqrt:"+Math.sqrt(16));//返回数据的平方根
System.out.println("round:"+Math.round(12.35));//四舍五入
System.out.println("round:"+Math.round(12.65));
System.out.println("random:"+Math.random());//返回一个随机数
}
}
12、 Scanner类
Scanner类可以实现我们从键盘录入数据。
使用步骤：
A:导入 import java.util.Scanner 类的上面。
B:创建对象
Scanner sc = new Scanner(System.in); //标准的键盘录入
C:通过对象使用功能
获取键盘录入的一个int类型的值
public int nextInt()
代码示例：
import java.util.Scanner;
class ScannerDemo
{
public static void main(String[] args)
{
//创建对象
Scanner sc = new Scanner(System.in);
//使用功能
int number = sc.nextInt();
System.out.println("number:"+number);
}
}
案例：
（1）求两个数的和：
import java.util.Scanner;
class ScannerTest
{
public static void main(String[] args)
{
//创建对象
Scanner sc = new Scanner(System.in);
//获取数据
System.out.println("请输入一个数据：");
int x = sc.nextInt();
System.out.println("请在输入一个数据：");
int y = sc.nextInt();
int result = sum(x,y);
System.out.println("结果是："+result);
}
public static int sum(int a,int b)
{
return a+b;
}
}
（2）猜数字小游戏：
/*
猜数字小游戏
A:程序产生一个随机数据。(这个数据是1-100之间的)
(int)(Math.random()*100)+1
B:请从键盘录入数据，用Scanner实现。
C:判断数据
如果键盘录入数据大于随机数，那么提示数据大了
如果键盘录入数据小于随机数，那么提示数据小了
如果键盘录入数据等于随机数，那么提示恭喜你,猜对了
D:想办法实现多次猜，当正确后退出程序。
统计猜多少成功。
*/
import java.util.Scanner;
class GuessNumber
{
public static void main(String[] args)
{
int num = (int)(Math.random()*100+1);//产生一个1-100的随机数
int count = 0;//定义计数器
System.out.println("请输入一个1-100之间的数字：");
Scanner sc = new Scanner(System.in);//从键盘获取数据
while(true)
{
int a = sc.nextInt();//读取键盘录入的数据
if (a<1 || a>100)//判断是否是1-100之间的数
{
System.out.println("您输入的数据有误");
continue;//如果不是1-100之间的数，继续循环
}
else
{
count++;//每输入一次正确的值count自增一次
if (a>num)//如果输入的数据比产生的数据大了
{
System.out.println("您输入的"+a+"大了");
}
else if(a