public class 文件名 {

public static void main（String[] args）{

方法名称();

System.out.println(“Hello World！”); //打印输出语句

====if else语句:

int age =16;

if (age >=18){

System.out.println("进入网吧");

}判断条件

else if （age>12）{

System.out.println("买小吃");

}

else{

System.out.println("回家吃饭");

}

====switch语句:

int num = 1;

switch (num){

case 1:

System.out.println("星期一");

break;

case 2:

System.out.println("星期二");

break;

case 3:

System.out.println("星期三");

break;

…………

default:

System.out.println("数据不合理");

break;//最后一个break语句可以省略但是强烈建议不要省略。

}

====for循环：

for(int i = 1;i <= 100;i++){

System.out.println("?" + i);

}

System.out.println("停止");

………………

for(int j = 0;j <= 5;i++){

for(int i = 0;i<= 20;i++){

System.out.print("*" );//println去ln可以不换行

}

}

System.out.println();//换行

====while 和 do while循环：

int i = 1;

while(i <= 10){

System.out.println("?" + i);

i++;

}

int i = 1;

do{

System.out.println("?" + i);

i++;

}while (i <= 10);

}

}

int 名字=（int）数字 强制转换成int

int result 1=x(不能是常量)++;

==等于，！=不等于，&&0与，||或，！取反，%=看余数 （num % 2 ==0）//除以2余数为0

int max = a > b ? a : b;或者System.out.println(a > b ? a : b)；

变量名称=条件判断？表达式A：表达式B; //a > b ？ a : b如果成立为true，那么将表达式A的值赋予左侧变量，反之怡然

break 打断、continue 跳过

if (i == 4){

break; 或者 continue;

}

==============

三要素：返回值、方法名称、参数列表

public class 文件名 {

public static void main（String[] args）{

int number=sum(a:15,b:25);//赋值调用

number += 100;

System.out.println("变量的值"+nember);

}

public static int sum(int a,int b){

System.out.println("执行" );

int result = a + b;

return result;//输出结果为：140

}

}

public class 文件名 {

public static void main（String[] args）{

method1(a:10,b:20);//赋值调用

System.out.println("========");

method2();

}

//两个书相乘

public static int method1(int a,int b){

int result = a * b;

System.out.println(结果是："+resultr);//输出结果为200

//固定运行十次

public static void method2()（String[] args）{

for(int i = 0;i < 10,i++){

System.out.println("Hello,World"+i);

}

}

}

}

void 方法下面不能写 return result;

对于有返回值的方法，可以使用单独调用、打印调用或者赋值调用。但没有返回值的方法，只能使用单独调用。

public class 文件名 {

public static void main(String[] args){

//我是mian方法，我来调用你，你来帮我计算，算完后把结果告诉我的num变量。

int num = getSum(a:10,b:20);

System.out.println("返回值是："+ unm);

System.out.println("=======");

prinSum(a:100,b:200);

}

//负责两个数字相加。返回值int，谁调用的就把结果告诉谁。

public static int getSum(int a,int b){

int result = a+ b;

return result;

}

//负责两个数字相加，应为没有返回值，我只能自己打印输出。

public static void main(String[] args）{

int result = a + b;

System.out.println("结果是："+ result);

}

}

//判断两个数字是否相同

public class 文件名 {

public static void main（String[] args）{

System.out.println(isSame(a:10,b:20));//false

System.out.println(isSame(a:20,b:20));//true

}

public static boolean isSame(int a,int b){

return a == b;

}

}

返回值：有返回值，计算结果是一个int数字

方法名称：getSum

参数列表：数据范围已确定，不需要告诉我任何条件，不需要参数

public class 文件名 {

public static void main（String[] args）{

System.out.println("结果是："+ gerSun/*方法名称*/());

}

public static int gerSum(){

int sum = 0;

for(int i = 1;i <= 100;i++){

sum += i;

}

return sum;

}

}

1.方法应该定义在类当中，但不能在方法当中在定义方法，不能嵌套。

2.方法定义的前后顺序无所谓。

3.方法定义之后不会执行，如果希望执行，一定要调用：单独调用、打印调用、赋值调用。

4.如果方法有返回值，必须写上“return 返回值；”，不能没有。

5.return后面的返回值数据，必须和方法的返回值，对应起来。

public static int method1(){

return 10；//√

return 10.0;//×

}

6.void 方法下面不能写return后面的返回值，只能些自己。

public static void method2(){

return;//√

return 10;//×

}

7.对于void方法当中最后一行的return可以不写。

8.一个方法当中可以有多个return语句，但必须保证只有一个会被执行到。

public static int method1(){

if(a >b){

return a;

}else{

return b;

}

Overload 重载

方法重载玉下列因素相关：

1.参数个数不同

2.参数类型不同

3.参数的多类型顺序不同

方法重载玉下列因素无关：

1.与参数的名称无关

2.与方法的返回值无关

public class 文件名 {

public static void main（String[] args）{

System.out.println(sum(a: 10,b: 20));

System.out.println(sum(a: 10,b: 20,c: 30));

}

public static int sum(int a,int b){

System.out.println("有2个参数的方法执行！");

return a + b;

}

public static int sum(int a,int b,int c){

System.out.println("有3个参数的方法执行！");

return a + b + c;

}

public static int sum(double a,double b){

System.out.println("有2个参数的方法执行！");

return (int) (a + b);

}

//错误写法

public static int sum(int x,int y){

System.out.println("有2个参数的方法执行！");

return x + y;

}

//错误写法

public static double sum(int a,int b){

System.out.println("有2个参数的方法执行！");

return a + b;

}

}

比较两个数据是否相等。

参数类型分别是两个byte,两个short,两个int,两个long,并在main方法中进行测试。

执行方法不一样。

public class 文件名 {

public static void main(String[] args){

byte a = 10;

byte b = 20;

System.out.println(isSame(a,b));

System.out.println(isSame((short)20,(short)20));

System.out.println(isSame(a:11,b:12));

}

System.out.println(isSame((short)20,(short)20));

System.out.println(isSame(a:10L,b:10L));

}

public static boolean isSame(byte a,byte b){

System.out.println("两个byte参数的方法执行！");

if (a==b){

dame = true;

}else{

same = false;

}

return same

}

}

public static boolean isSame(short a,short b){

System.out.println("两个short参数的方法执行！");

return = a == b ? true : false;

return same;

}

public static boolean isSame(int a, int b){

System.out.println("两个int参数的方法执行！");

return a == b;

}

public static boolean isSame(long a, long b){

System.out.println("两个long参数的方法执行！");

if (a==b){

return true;

}else{

return false;

}

}

}

open 重载

在调用输出语句是，println方法其实就是进行了多种数据的重载形式。

public class 文件名 {

public static void open(){}

public static void open(int a){}

public static void open(int a,int b){}

public static void open(short a,short b){}

}

public class 文件名 {

public static void main(String[] args){

myPrint(num:100);//int

myPrint(str:"Hello");//String

}

public static void myPrint(byte/short/int/ling/fooat/double/char){

System.out.println(num);

}

public static void myPrint(char zifu){

System.out.println(zifu);

}

public static void myPrint(boolean is){

System.out.println(is);

}

public static void myPrint(String str){

System.out.println(str);

}

}

//

1.数组是一种引用数据类型。

2.数组当中的多个数据类型必须统一。

3.数组的长度在程序的运行期间不可改变

数组的初始化，在内存当中创建一个数组，并且想其中赋予一些默认值。

两种常见的出事话方式：

1.动态初始化（指定长度）

2.静态初始化（指定内容）

使用建议：

如果不确定数组当中的具体内容，用动态初始化；确定就用静态初始化。

动态初始化数组的格式：

数组类型[] 数组名称 = new 数组类型[数组长度]；

public class 文件名 {

public static void main(String[] args){

//创建一个数组，里面可以存放300个int数据

int[] arrayA = new int[300];

//创建一个数组，里面可以存放10个double数据

  double[] arrayB = new double[10];

//创建一个数组，里面可以存放5个字符串

  String[] arrayC = new String[5];

}

}

静态初始化数组的格式：

数组类型[] 数组名称 = new 数组类型[]{元素1，元素2，…}；

public class 文件名 {

public static void main(String[] args){

//创建一个数组，里面装的全是int数字，具体为：5、15、25

int[] arrayA = new int[]{5,15,25};

//创建一个数组，用来装字符串，“Hello”、“Word”、“Java”

  String[] arrayB = new String[]{“Hello”,“Word”,“Java”};

}

}

静态初始化数组的省略格式：

数组类型[] 数组名称 = {元素1，元素2，…}；

1.静态初始化没有指定长度，但任然会自动推算长度。

2.静态初始化标准格式可以拆分成两个步骤。

3.静态初始化一旦使用了省略格式，就不能拆分成两个步骤了。

4.动态初始化也可以拆分成两个。

public class 文件名 {

public static void main(String[] args){

//省略格式的静态初始化

int[] arrayA ={5,15,25};

 //静态初始化的标准格式，可以拆分成两条

int[] arrayB;

arrayB = new int[]{10,20,30};

int[] arrayC;

arrayC = new int[5];

}

}

===========

Java内存需要划分5个区域：

1.栈（Stack）：存放的都是方法中的局部变量。方法的运行一定要在栈当中。

局部变量：方法的参数，或者是方法{}内部的变量

作用域：一旦朝珠作用域，立刻从栈内存当中消失。

2.堆（Heep）：凡是new出来的东西，都在堆当中。

堆内存里面的东西都有一个地址值：16进制

堆内存里面的数据，都有一个默认值。规则：

如果是整数类型，默认值为0;

如果是浮点类型，默认值为0.0;

如果是字符类型，默认值为'\u000';

如果是布尔类型，默认值为false;

如果是引用类型，默认值为'null'。

3.方法区（Method Area）：存储.class相关信息，包含方法的信息。

4.本地方法栈（Native Method Stack）：与操作系统相关。

5.寄存器（pc Register）：与CPU相关。

public class 文件名 {

public static void main(String[] args){

int[] array = new int[3];

array[1] = 10;

array[2] = 20;

System.out.println(array);//地址值

  System.out.println(array[0]);//0

  System.out.println(array[1]);//10

  System.out.println(array[2]);//20

}

}

获取数组长度，格式

数组名称.Length

public class 文件名 {

public static void main(String[] args){

int[] arrayA = new int[3];

System.out.println(arrayA.length);

int[] arrayB = {10,20,30,51,5,3,51,42,6}

int len = arrayB.length;

System.out.PRintln("arrayB数组的长度是：" + len);

}

}

求出最大值：

public class 文件名 {

public static void main(String[] args){

int[] array = {10,20,50,40,30}

for (int i = 1,i < array.length;i ++){

if （array[] > max）{

max = array[i];

}

}

System.out.println("最大值是：" + max);

}

}

数组元素反转：

public class 文件名 {

public static void main(String[] args){

int[] array = {10,20,30,40,50}

for (int i = 0,i < array.length;i ++){

System.out.println(array[i]);

}

for (int i = 0,i < array.length;i ++){

inr temp = array [min];

array[min] = array[max];

array[max] = temp;

}

for (int i = 0,i < array.length;i ++){

System.out.println(array[i]);

}

}

}

数组可以作为方法的参数。

当调动方法时，向方法的小括号进行传参，传递进去的其实是地址值。

public class 文件名 {

public static void main(String[] args){

int[] array = {10,20,30,40,50};

printArray(array);

System.out.println(array"====AAA====");

printArray(array);

System.out.println(array"====BBB====");

}

public static void main(String[] array){

for (int i = 0,i < array.length;i ++){

System.out.println(array[i]);

}

}

}

任何数据类型都能作为方法的参数类型，或者返回值类型。

数组作为方法的参数，传递进去的其实是数组的地址值。

数组作为方法的返回值，返回的其实也是数组的地址值。

public class 文件名 {

public static void main(String[] args){

int[] result = calculate(a:10,b:20,c:30);

System.out.println("main方法内部数组是：");

System.out.println(result);

System.out.println("总和：" + resule[0]);

System.out.println("平均数：" + resule[1]);

}

public static void main(String[] array){

int sum = a + b + c;

int agv = sum / 3;

int[] array = {sum,avg};

System.out.println("calculate方法内部数组是："）;

System.out.println(array);

return array;

}

}

=========

面向过程:每一个具体的步骤都要亲力亲为，详细处理每一个步骤和细节。

面向对象：不关心具体步骤，而是找一个已经具有该功能的人来做事。

public class 文件名 {

public static void main(String[] args){

int[] array = (10,20,30,40,50);

//要求打印格式：[10,20,30,40,50]

//面向过程:每一个具体的步骤都要亲力亲为。

System.out.println("[");

for (int i = 0,i < array.length;i ++){

if (i == array.length - 1){

System.out.print(arry[i] + "]")

}else{

System.out.print(array[i] + ",");

}

}

System.out.print("================");

//使用面向对象

//我一个JDK给我们提供好的Arrays类，

//其中一个toString方法，直接就能把数组变成想要的格式的字符串。

System.out.print(Arrays.toString(array));

}

}

定义一个Student

注意事项：

1.成员变量是直接卸载类当中的，在方法外边。

2.成员方法不要写static关键字。

public class 文件名 {

String name；

int age;

public static void eat(){

System.out.println("吃饭");

}

public static void sleep(){

System.out.println("睡觉");

}

public static void sleep(){

System.out.println("学习");

}

}

通常情况下，一个类并不能直接使用，需要根据类创造一个对象，才能使用。

1.导包：也就是支出需要使用的类，在什么位置。

import 包名称.类名称；

import cn.itcast.day06.demo01.Student;

对于和一个当前类属于一个包的情况。可以省导包语句不写。

2.创建，格式:

类名称 对象 = new 类名称();

Student stu = new Student();

3.使用，分两种:

使用成员变量：对象名.成员变量名

使用成员方法：对象名.成员方法名（参数）

（也就是，想用谁，就用对象名点谁。）

public class 文件名 {

public static void sleep(){

//1.导包。

//我需要使用的Student类，和我自己文件位于同一包下，所以省略导包语句不写

//2.创建，格式：

//类名称 对象名 = new 类名称();

//根据Student类，创建了一个名为stu的对象

Student stu = new Student();

//3.使用其中的成员变量，格式：

//对象名.成员变量名

System.out.println(stu.name);

System.out.println(stu.age);

System.out.println("");

//改变对象当中的成员变量数值内容

//stu.将右侧的字符串，赋值交给stu对象当中的name成员变量

name = "刘亦菲";

stu.age = 18;

System.out.println(stu.name);

System.out.println(stu.age);

//4.使用对象的成员方法，格式：

//对象名.成员方法名（）

stu.eat();

stu.sleep();

stu.study();

}

}

定义一个类，用来模拟“手机”事物。

属性：品牌、价格、颜色

行为：打电话、发短信

public class Phone {

//成员变量

String brand;//品牌

double price;//价格

String color;//颜色

//成员方法

public void call(String who){

Stsytem.out.println("给"+ who + “打电话”);

}

public void sendMessage(){

Stsytem.out.println("发短信”);

}

}

//创建一个类

public class PhoneSame {

public static void main(String[] args){

Phone one = new Phone();

Phone one = new Phone();

Stsytem.out.println(one.brand);//null

Stsytem.out.println(one.price);//0.0

Stsytem.out.println(one.color);//null

Stsytem.out.println("=========");

one.brand = "苹果"；

one.price = 8388.0;

pne.color = "黑色"；

Stsytem.out.println(one.brand);//苹果

Stsytem.out.println(one.price);//8388.0

Stsytem.out.println(one.color);//黑色

Stsytem.out.println("=========");

one.call(who:“乔布斯”);

one.sendMessage();

Stsytem.out.println("=========");

//将one当中保存的对象地址值赋给two

Phone tow = one;

Stsytem.out.println(one.brand);//null

Stsytem.out.println(one.prince);//0.0

Stsytem.out.println(one.color);//null

Stsytem.out.println("=========");

two.brand = "三星"；

two.price = 5999.0;

pne.color = "蓝色"；

Stsytem.out.println(two.brand);//苹果

Stsytem.out.println(two.price);//8388.0

Stsytem.out.println(two.color);//黑色

Stsytem.out.println("=========");

two.call(who:“乔布斯”);

two.sendMessage();

}

}

//新建一个类

public class PhoneParam {

public static void main(String[] args){

Phone one = new Phone();

one.brand = "苹果"；

one.price = 8388.0;

pne.color = "黑色"；

method(one);//传出去的其实是地址 值

}

public static void method(Phone param){

Stsytem.out.println(param.brand);//苹果

Stsytem.out.println(param.price);//8388.0

Stsytem.out.println(param.color);//黑色

}

}

//新建一个类

public class PhoneReturn{

public static void main(String[] args){

Phone two = getPhone();

Stsytem.out.println(two.brand);//苹果

Stsytem.out.println(two.price);//8388.0

Stsytem.out.println(param.color);//黑色

}

public static void method(Phone param){

Stsytem.out.println(param.brand);//苹果

one.brand = "苹果"；

one.price = 8388.0;

pne.color = "土豪金"；

return one;

}

}

局部变量和成员变量

1.定义的位置不一样【重点】

局部变量：在方法的内部、成员变量：在方法的外部，直接写在类当中

2.作用范围不一样【重点】

局部变量：只有方法当中才可以使用

成员变量：整个类都可以通用

3.默认值不一样【重点】

局部变量：没有默认值，如果要想使用，必须手动进行赋值

成员变量：如果没有赋值，会有默认值，规则和数组一样

4.内存的位置不一样（了解）

局部变量：位于栈内存

成员变量：位于堆内存

5.生命周期不一样（了解）

局部变量：随着方法进栈而生，出栈而亡

成员变量：随着对象创建而生，随着对象进垃圾桶而小时

/

面向对象三大特征：封装。继承。多态。

封装性在java当中的体现：

1.方法就是一种封装

2.关键字private也是一种封装

public class PhoneReturn{

public static void main(String[] args){

int[] array = {5,15,20,100};

int max = getMax(array);

System.out.print("最大值：" = max);

}

//给我一个数组，我换你一个最大值

public static void method(Phone param){

int max = array[0];

for(int i = 1;i < array.length;i++){

max = array[i];

}

return max;

}

}

问题描述：定义person的年龄时，无法组织不合理的数值设置进来。

解决方案“：用private关键字将需要保护的成员进行修饰。

一旦使用了private进行修饰，那么本类当中仍然可以随意访问，但是！超出了本类范围之外就不能再直接访问了。

间接访问private成员变量，就是定义一堆Getter/Setter方法

必须叫setXxx或者是getXxx命名规则。

对于Getter来说，不能有参数，返回值类型和成员变量对应；

对于Stter来说，不能有返回值，参数类型和成员变量对应。

public class Person{

String name;//姓名

private int age;//年龄

public void show(){

System.out.println("我叫：" + name = "年龄：" = age);

}

//这个成员方法，专门用于向age设置数据

public void setAge(int num){

if (num <120 && num>= 9){

age = num;

}else{

System.out.print("数据不合理!" );

}

}

//这个成员方法，专门用于获取age的数据

public int setAge(int num){

return age;

}

}

//创建一个类

public class Student{

private String name;

public static void main(String[] args){

person person = new person ();

person.show();

person.name = "wwd";

//person.age = -20；//方法错误

person.setAge(20);

person.show();

}

}

//创建一个学生类

对于基本类型当中的boolean值，Getter方法一定要写成isXXX的形式，而setXXX的规则不变。

public class Student{

private String name;//姓名

private int age;//年龄

private boolean male;//是不是爷们

public void setMale(boolean b){

male = b;

}

public boolean isMale(){

return male;

}

public void setName(String str)){

name = str;

}

public void gatName(){

return name;

}

public void setAge(int num){

age = num;

}

}

//创建一个类

public class DemoStudent{

public static void main(String[] args){

person stu = stu Student();

person.show();

stu.setName = ("wwd");

stu.setAge(20);

stu.setMale(true);

System.out.println("我叫：" + stu.setName());

System.out.println("年龄：" + stu.setAge());

System.out.println("是不是爷们：" + stu.isMale());

}

}

当方法的局部变量和类的成员变量重名时，根据“就近原则”，优先使用局部变量。

如果需要访问本类当中的成员变量，需要使用格式：this.成员变量名

“通过谁调用的方法，谁就是this”

public class Person{

String name;//我方的名字

//参数name是对方的名字

//成员变name是我方的名字

public void sayHello(String[] name){

System.out.println(name +"你好，我是" + this.name);

}

}

//创建一个类

public class DemoPerson{

public static void main(String[] args){

person preson = new Person();

//设置我方名字

person.name = "zr";

person.sayHello("mg");

}

}

构造方法是专门创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。

格式：

public 类名称(参数类型 参数名称){

方法体

}

注意事项：

1.构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样。

2.构造方法不需要写返回值，连void都不写。

3.构造方法不能return一个具体的返回值。

4.如果没有编写构造方法，那么编译器将会默认一个构造方法，没有参数、方法体什么事都不做。一旦编写了至少一个构造方法，那么编译器将不再赠送。

5.构造方法也是可以重载的。

重载：方法名称相同，参数列表不同。

public class Student{

public Student(){

System.out.println(“构造方法执行啦！”);

}

}

//无参数

public class Student{

public Student(){

}

}

//全参数

public class Student{

public Student(String name,int age){

this.name = name;

this.age = age;

}

}

//使用方法

public class DemoStudent{

public static void main(String[] args){

Student stu = new Student();

}

}

=======

public class Student{

private String name;

private String age;

public Student(String name,int age){

System.out.println(“构造方法执行啦！”);

}

public void setNamet(String name){

sthis.name = name;

}

public String getName(){

return name;

}

public void setAge(int age){

this.age = age;

}

public int setAge(){

return age;

}

}

//创建一个类

public class DemoStudent{

public static void main(String[] args){

Student stu2 = new Student("刘亦菲"，20);

System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getName());

//改年龄

stu2.setAge(21);

System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getName());

}

}

Scanner类的功能：可以实现键盘输入数据，到程序当中。

应用类型的一般使用步骤：

1.导包

import 包路径.类名称；

如果需要使用的目标，和当前类位于同一个包下，则可以省略导包语句不写。

只有java.long包下的内容不需要导包，其他的包都不需要import语句。

2.创建

类名称 对象名 = new 类名称();

3.使用

对象名。成员方法名()；

获得键盘输入的一个int数字：int num = sc.nextInt();

获得键盘输入的一个字符串：String str = sc.next();

//1.导包

import java.util.Scanner;

public class Demo01Scanner{

public static void main(String[] args){

//备注：System.in代表从键盘输入

//2.创建

Scanner sc = new Scanner(System.in);

//3.获得键盘输入的int数字

int num = sc.nextInt();

System.out.println(“输入的int数字是：” + num);

//4.获得键盘输入的字符串

String str = sc.next();

System.out.println(“输入的字符串是：” + str);

}

}

public class Demo02Scanner{

public static void main(String[] args){

Scanner sc = new Scanner(System.in);

System.out.println(“请输入第一个数字：”);

int a = sc.nextInt();

System.out.println(“请输入第二个数字：”);

int b = sc.nextInt();

int result = a + b;

System.out.println(“结果是：” + result);

}

}

题目：

键盘输入三个int数字，然后求出其中的最大值。

思路：

1.既然是键盘输入，肯定需要用到Scanner

2.Scanner三个步骤：导包、创建、使用nextInt()方法

3.既然是三个数字，那么调用三次nextInt（）方法，得到三个int变量

4.无法同时判断三个数字谁最大，应该转化为两个步骤

5.打印结果

public class Demo02Scanner{

public static void main(String[] args){

Scanner sc = new Scanner(System.in);

System.out.println(“请输入第一个数字：”);

int a = sc.nextInt();

System.out.println(“请输入第二个数字：”);

int b = sc.nextInt();

System.out.println(“请输入第二个数字：”);

int c = sc.nextInt();

int result = a + b;

int temp = a > b ? a :b;

int max = temp > c ? temp :c;

System.out.println(“最大值是：：” + max);

}

}

匿名对象

注意事项：匿名对象只能使用唯一的一次，下次再用只能在创建一个新对象。

使用建议：如果确定只有一个对象是，就可以使用

public class person{}

string name;

public void showName(){

System.out.println("我叫：" + name);

}

}

创建一个类

public class Demo01Anonymous{

public static void main(String[] args){

Person one = new Person();

one.name = "wwd";

one.showName();

System.out.println(“========”);

newPerson().name = "王冰冰";

new Person().showName();//我叫：null

}

}

//匿名对象的参数和返回值

public class Demo02Anonymous{

public static void main(String[] args){

//普通使用方式

Scanner sc = new Scanner(System.in);

int num = sc.nextInt();

//匿名对象的方式

new num = new Scanner(System.on).nextInt();

System.out.println("输入的是：" + num);

//使用一般写法输入参数

Scanner sc = new Scanner(System.in);

methodParom(sc);

//使用匿名对象来进行转参

methodParam (new Scanner(System.in));

Scanner sc = methodReturn();

sc.nextInt();

System.out.println("输入的是：" + num);

}

public static void methodParam(Scanner sc){

int nu = sc.nextInt();

System.out.println("输入的是：" + num);

}

public static void methodParam(Scanner sc){

return mew Scanner(System.in);

}

}