Java基础语法

IDE的使用

IDE(Intergrated Development Environment)集成开发环境,是用于提供程序开发环境的应用程序,一般包括代码编辑器、编译器、调试器和图形用户界面等工具。

常用的java开发工具：

Intellij IDEA ：简称IDEA，是java编程语言开发的集成环境。由JetBrains公司出品。

Eclipse：免费，由Eclipse基金会管理。

注释

概念：对程序功能的说明，用特殊符号标记，不会被执行。

// 单行注释 快捷键Ctrl+/

/*
* 多行注释 快捷键Ctrl+shift+/ 开启  Ctrl+shift+\  取消
*/

/**
* 文档注释 为类,方法(函数),属性功能进行说明,可在调用时提示其功能介绍.
*/

关键字

概念：被Java语言赋予了特殊含义的单词，用来修饰如类，属性，变量。

特点：关键字中所有的字母都是小写。

用于定义数据类型的关键字：class ； interface ； enum ； byte ； short ； int ； long ； float ； double ； char ； boolean ； void 。

用于定义数据类型值的关键字：true ； false ； null 。

用于定义流程控制的关键字：if ； else ； switch ； case ； default ； while ； do ； for ； break ； continue ； return 。

用于定义访问权限修饰符的关键字：private ； protected ； public 。

用于定义类、函数、变量修饰符的关键字：abstract ； final ； static ；synchronized。

用于定义类与类之间关系的关键字：extends ； implements 。

用于定义建立实例及引用实例，判断实例的关键字：new ； this ； super ； instanceof 。

用于异常处理的关键字：try ； catch ； finally ； throw ；throws。

用于包的关键字：package ； import 。

其他修饰符关键字：native ； strictfp ； transient ； volatile ； assert 。

保留字：现有java版本尚未使用作为关键字，但以后的版本可能会作为关键字使用。标识符命名时要避免使用保留字。如goto、const。

标识符（命名）

Java对各种变量、方法、类等命名时使用的字符序列。通俗的讲：自己能命名的都叫标识符。

定义合法标识符的规则：

只能由26个英文字母大小写，0-9，_或$组成；
数字不可以开头；
不可以使用关键字和保留字，但能在整段名字中包含关键字和保留字；
Java中严格区分大小写，长度无限制；
标识符不能含空格。

同时，为了人们阅读代码的方便，会有一些约定俗称的命名规则：

“见名知意”
驼峰命名
类名的首字母大写
方法名、变量名首字母小写

Java中的名称命名规则：

包名：多单词组成时所有字母都小写：xxxyyyzzz;
类名、接口名：多单词组成时，第一个单词首字母小写，第二个单词开始首字母要大写：xxxYyyZzz;
常量名：所有字母都大写，单词间用下滑线连接：XXX_YYY_ZZZ

Java变量

概念：变量是程序中最基本的存储单元，程序执行中数值可变。

实质：变量是内存中的一小块区域，使用变量名类访问这区域，因此，每一个变量使用前必须申请(声明)，然后必须进行赋值（填充内容），才能使用。即变量是通过访问变量名来访问这块区域的。

变量要素：变量名 ， 变量要素 。

Java程序中每一个变量都属于特定的数据类型，在使用前必须对其声明，声明格式为：[修饰符] type varName [=value][,varName[=value]…];例如:

int i = 100 ;
int i1 , i2 , i3 = 10;
String s="hello";

public class VarDemo {
    //        声明变量
    public static void main(String[] args){
//        在声明中直接赋值
        int a = 10; //声明类型为整型，赋值为10

//        多个变量赋值
        int b=20,c=30,d=40; //声明三个变量bcd,赋值为20,30,40

//        先声明变量再赋值
        int e,f,g; //声明
        e = 50; //赋值
        f = 60;
        g = 70;

//      字符型String
//        String不是关键字,它是用类作为类型声明的变量,被称为引用类型变量.
        String str = "I love you";
    }

Java数据类型

概念：程序中对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。

特点：Java是一种强数据类型的语言，每个数据都必须指定类型，指定JVM分配内存空间。

数据类型(8种):

基本数据类型:
数值型:整型(byte,short,int,long);浮点型(double,float)
字符型:double;float
布尔型:boolean

引用数据类型:
类:class   <--   字符串在这里
接口:interface
数组:[]

整数类型

Java各整数类型有固定的表数范围和字段长度，不受操作系统的影响，以保证Java程序的可移植性。

注意：

1字节 = 8bit
使用的类型，在赋值时要注意值与类型相匹配。
Java中的整数值还可以用其他进制表示。
Java语言的整型常量默认为int型，声明long型需要在后面加"l"或"L"。

不同进制常量需注意：

二进制：”0B/0b"开头
八进制:"0"开头
十六进制:"0X"开头

整数类型的代码示例

//基本数据类型--整数型(integer)
public class IntegerDemo {
    public static void main(String[] args){
//        byte,占1个字节的存储空间,取值范围:-128 ~ 127
        byte a = -128;
        byte b = 127;

//        short,占2个字节的存储空间,取值范围:-32768 ~ 32767
        short c = -32768;
        short d = 32767;

//        int,占4个字节的存储空间,取值范围:-2^31 ~ 2^31-1
        int e = -2^31;
        int f = 2^31-1;

//        long,占8个字节的存储空间,取值范围:-2^63 ~ 2^63-1
        long g = -2^63;
        long h = 2^63-1;

//        整数值可以用其它进制表示
//        二进制:以0b/0B开头; 八进制以0开头; 十六进制:以0X开头
        int i = 0b1110; //二进制
        int j = 010070; //八进制
        int k = 0Xaee01; //十六进制

        System.out.print(a+"\n"+b+"\n"+c+"\n"+d+"\n"+e+"\n"+f+"\n"+g+"\n"+h+"\n"+i+"\n"+j+"\n"+k);

    }

浮点型

与整数类型一样,Java浮点类型有固定的表数范围和字段长度，不受平台影响。

浮点类型的两种表示形式：

十进制数形式，例如：3.14   314.0 ......

科学计数法形式，例如：3.14e2         3.14E2

注意：

Java浮点类型常量，默认为double型，如声明一个常量为float型，需要在数字后，面加f或F。
由于在计算机中的计算方式不同，4字节的浮点数float远远大于4字节和8字节的型。
计算机中，小数是以近似值的方式存在的

浮点类型的代码示例

//基本数据类型-浮点数(double and float)
public class FloatDemo {
    public static void main(String[] args){
//浮点型常量默认为double型,声明一个float型要在后面加上f或F
        float a = 1.23f;
        float b = 1.22f;
//     计算机中小数是以近似值的方式进行存储的
        System.out.println(a-b);
//float是四字节,double是八字节,都比整数型的long大
        double c=1.22;
        System.out.println(c == b);

    }

逻辑型

逻辑类型–boolean（布尔）型

boolean型适合于逻辑运算，一般用于程序流程控制。

注意，boolean型只允许取值为true或者false，不可以用1或0代替。

逻辑型代码示例

//基本数据类型--逻辑型(boolearn 型)
public class BooleanDemo {
    public static void main(String[] args){
        float a = 1.2f;
        float b = 1.1f;
        System.out.println(a-b==0.1f);//输出false
    }

字符类型

字符型 --> char

char型数据用来表示通常意义上的“字符”，char占2字节，字符型用单引号括起来的单个字符。例如：

char c1 = 'a';
char c2 = '中';

不能是char c1 = 'ab';cahr c2 = '中国'

字符型数据涵盖了世界上所有书面语的字符。

计算机表示字符的编码问题：

计算机底层都是二进制，人为的给其定义了编码表。
字符在不同的编码表上有一个对应的十进制数，最终在计算机上会以这个数存储。
最早的编码表是ASCII表（美国信息交换标准代码）
不同的国家会定义自己国家的编码：中国  GBK  GB2312
后来诞生了unicode编码表，里面包含了世界上各国的文字
utf-8是针对unicode的一种可变长度的字符编码

char运算

char类型是可以运算的，因为char在字符编码表中有对应的数值。

在Java中，对char类型字符运行时，直接当作对应码表的整数来对待。比如char c

=‘a’ + 1 ; 先将’a’升为int型,计算结果为98,对应的字符为’b’。

字符类型的代码示例

//基本数据类型--字符型
public class CharDemo {
    public static void main(String[] args){
/*
* char型数据用来表示通常意义上的"字符",char占2个字节,字符欧诺个单引号括起来的单个字符
*/
        char c = 'a';
        char b = '中';
/*
* 计算机底层都是二进制码
* 人为定义·编码表
* 字符在不同的编码表上有一个对应的十进制数，在计算机中使用这个数存储
* 最早的编码表-ASCII表（美国信息互换标准代码）
* 不同国家有自己的编码,如:中国:GBK   GB2312
*/
        System.out.println(c+0);//println:输出并换行
        System.out.print(b+0);

    }

基本数据类型转换

Java中可以从任意基本类型传型为另外的基本类型，Boolean型例外。

转换分为两种：默认（自动）转换和强制转换

默认转换
整型、字符型、浮点型的数据在混合运算中相互转换；
容量小的类型自动转换为容量大的数据类型；
数据类型按容量大小排序为：byte,short,char-->int-->long-->float-->double;
byte,short,char三者之间不会互相转换，在计算时首先转为int类型。

强制转换
容量大的数据类型转为容量小的数据类型，需要加上强制转换符，如int y = (int)x ;
问题：溢出；精度降低；

注意：有多种类型的数据混合运算时，系统会首先自动将所有数据类型转换为容量最大的哪一种，然后再进行运算。

基本数据类型转换代码示例

//基本数据类型的转换
public class DataTypeDemo {
    public static void main(String[] args){
/*默认转换
* 容量小的会自动转换成容量大的数据类型,原因就是容量大的可以轻易装下小的
* 参与混合运算时,所有小容量的会自动转成大容量的
* 数据类型(容量大-->小):byte,short,char-->int-->long-->float-->double
* 注意:byte,short,char之间不会互相转换,他们都会在计算时自行转为int类型*/
        byte a = 100;//整型byte
        long a1 = 1000l;//长整型long
        float b = a;//把a赋值给b.整型自动转换为浮点型
        b = b * a + a1;//混合运算中所有容量小的都转为容量大的,这里的小容量都转为了浮点型
        System.out.println(b+"\t"+getType(b));//11000.0	class java.lang.Float

/*强制类型转换
* 容量大的转换为容量小的
* 问题：溢出；精度降低；小的装不下大的*/
        short c1 = 258;
        byte c2 = (byte)c1;
        System.out.println(c2);//输出2，溢出了

        double n = 0.2 ;//浮点型
        int i=1,j=1;//整型
        i *= n;//对原本浮点类的a=0.2进行了强制类型转换,变为了a=0
        System.out.println(i +"\t"+ getType(i));//0	class java.lang.Integer

    }

//    获取变量数据类型的方法
    private static String getType(Object a){
        return a.getClass().toString();
    }

运算符

Java支持如下运算符

算术运算符：  +，-，*，/，%，++，--
字符串连接运算符：+ 
关系(比较)运算符： >，<，>=，<=，==，!=
逻辑运算符： !，& ， |  ， &&，||
赋值运算符：  =  ，+ =，- =，* =，/ =
条件运算符
位运算符

算数运算符

+ 正数 加法 字符串连接
- 负数 减法
* 乘法
/ 除法
% 取余
++ 自加 混合运算时,++在前先自增再运算,++在后先运算后自增
-- 自减 混合运算时,--在前先自减再运算,--在后先运算后自减

代码示例

//算数运算符
public class CountDemo {
    public static void main(String[] args){
        /*算数运算符
        * + 正数 加法 字符串连接
        * - 负数 减法
        * * 乘法
        * / 除法
        * %取余
        * ++ 自加
        * -- 自减
        */

//        +
        int a = 5;
        int a1 = +10;
        char a2 = 'b';
        String a3 = "20";
        System.out.println(a+a1);
        System.out.println(a2+a1); //char 参与运算 98+10=108
        System.out.println(a3+a1); //字符串连接,当字符串+数字时会连接不运算  2010

//        -
        int b = -20;
        int b1 = 3;
        System.out.println(a2-b); //char型可算
        System.out.println(b-b1);

//        * /
        System.out.println(a2*b1);
        System.out.println(b/a);

//        %
        System.out.println(b%b1);

//        ++ 自加 ++在前先自加,++在后后自加
        int c=5;
        c++; //c=c+1
        ++c; //c=c+1
        System.out.println(c);

        int d,e;
        d = c++ + 1;//++在后,先参与运算得d=8,再进行自加得c=8
        System.out.println(c+"\n"+d);
        e = ++c + 1;//++在前,先进行自加得c=9,再参与运算得e=10
        System.out.println(c+"\n"+e);

//        --同++

    }

比较运算符

比较运算符的结果都是boolean型,要么是true,要么是false。

== 相等于
!= 不等于
< 小于
> 大于
<= 小于等于
>= 大于等于

逻辑运算符

& 逻辑与
| 逻辑或
! 逻辑非
&& 短路于 遇到第一个false就短路,后面不再看了
|| 短路或 遇到第一个true就短路,后面不再看了
^ 逻辑异或 同假异真,异或追求的是"异"。

比较运算符和逻辑运算符的代码示例

//比较运算符-逻辑运算符
public class ComepareLogicDemo {
    public static void main(String[] args){
//        比较运算符
        int a1=1,a2=1;
        System.out.println(a1==a2);
        System.out.println(a1!=a2);
        System.out.println(a1<=a2);
        System.out.println(a1>=a2);
        System.out.println(a1>2);
        System.out.println(a1<a2);

//        逻辑运算符
        byte b1=10;
        byte b2=20;
//      &逻辑与
        System.out.println(b1<b2 & b1>b2); //true & false = false
        System.out.println(b1<b2 & b1<b2); //true & true = true
        System.out.println(b1>b2 & b1>b2);//false & false = false
//      &短路与:遇到第一个flase就短路,后面的表达式不再进行
        System.out.println(b1>b2 && b1<b2); //false && true = false
        System.out.println(b1<b2 && b1<b2); //true && true = true
        System.out.println(b1>b2 && b1>b2);//false && false = false
//      |逻辑或
        System.out.println(b1>b2 | b1<b2); //false | true = true
        System.out.println(b1<b2 | b1<b2); //true | true = true
        System.out.println(b1>b2 | b1>b2);//false | false = false
//      ||短路或:遇到第一个true就短路,后面表达式不在进行
        System.out.println(b1>b2 || b1<b2); //false || true = true
        System.out.println(b1<b2 || b1<b2); //true || true = true
        System.out.println(b1>b2 || b1>b2);//false || false = false
        System.out.println(b1<b2 || b1>b2);//true || false = true
//      !逻辑非
        System.out.println(! (b1>b2));//!false = true
//      ^逻辑异或:同假异真,异或,追求的是"异"
        System.out.println(b1>b2 ^ b1<b2); //false ^ true = true
        System.out.println(b1<b2 ^ b1<b2); //true ^ true = false
        System.out.println(b1>b2 ^ b1>b2);//false ^ false = false
        System.out.println(b1<b2 ^ b1>b2);//true ^ false = true
    }

赋值运算符

符号 : “ = ”

当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。支持连续赋值。

扩展赋值运算符： +=, -=, *=, /=, %=

代码示例

//赋值运算符
public class AssignDemo {
    public static void main(String[] args){
        /*赋值运算符
        * 符号：=
        * 当“=”两端数据类型不一样时，可以使用默认类型转换或
        * 强制类型转换原则进行处理可连续赋值
        * 扩展赋值运算符：+= -= *= /= %=  */
        int a = 10;
        float b = 20.2f;
        a += b;
        System.out.println(a + "\t" + getType(a));//30	class java.lang.Integer
        a = (int)b;
        System.out.println(a+ "\t" + getType(a));//20	class java.lang.Integer
    }
//    获取数据类型的方法
    private static  String getType(Object a){
        return a.getClass().toString();
    }

条件运算符

语法：（条件表达式）？表达式1：表达式2；

条件表达式为true时执行表达式1，为false时执行表达式2

表达式1和表达式2为同种类型

条件运算符和if - else的联系与区别：

条件运算符可简化if - else语句
条件运算符要求必须返回一个结果
if后的代码块可有多个语句

代码示例

//条件运算符
public class ContationDemo {
//    （条件表达式）？表达式1：表达式2；
//    true  执行表达式1；false  执行表达式2；
    public static void main(String[] args){
        int a = 10;
        int b = 20;
        char chr1='真';
        char chr2='假';
        char char3=(a<b & a>b) ? chr1 : chr2 ;//必须返回一个结果,这个结果需要有东西接着
        System.out.println(char3);
    }

位运算符

bit（比特位）的运算，执行效率高

日常开发并不常用，但巧妙的使用可以节省运行开销，优化算法。

| ^ | 相同二进制位进行 ^ 运算，结果是0；1^1=0 , 0^0=0
不相同二进制位 ^ 运算结果是1。1^0=1 , 0^1=1 |
| ~ | 正数取反，各二进制码按补码各位取反
负数取反，各二进制码按补码各位取反 |

代码示例

//位运算
public class BitDemo {
    public static void main(String[] args){
        /*位运算
        * 比特位（二级制代码）的运算
        * 日常开发不常用，但巧妙使用可以节省运行开销，优化算法*/

//        << 左移,移动一位相当于*2,空位补0
        int a = 2;// 0010
        System.out.println(a<<2);//左移两位 1000=8

//        >> 右移,移动一位相当于*1/2,被移动的数最高为是1,右移后空位补1;最高位是0,空位补0
        int b = 8;//1000
        System.out.println(b>>1);//右移一位 0100=4

        /*
          0011
          0100   都为1结果为1
          0000
         */
        System.out.println(3&4);

        /*
          0011
          0100
          0111   ==7
         */
        System.out.println(3|4);

         /*
          0011
          0100
          0111 =7
         */
        System.out.println(3^4);

        //逻辑非  取反
        System.out.println(~3);
    }

表达式的运算顺序

控制台输入

我们要知道在之后的编程项目中控制台输入是不需要的,所有的数据输入都是有由前端界面完成,引入控制台输入只是为了方便大家学习和程序测试使用.

头文件导入java.util.Scanner;
使用标准输入串System.in
使用Scanner取得一个字符串或者一组数字
新增一个Scanner对象时需要一个System.in对象,因为实际上还是System.in在取得用户输出.
next()方法用以取得用户输入的字符串
nextInt()取得的输入字符串转换为整数类型
nextFloat()转为浮点数.......等等

例子:创建一个Scanner对象,传入一个输入流对象
Scanner s = new Scanner(System.in);
int m = s.nextInt();
float n = s.nextFloat();

public static void main(String[] args){
    Scanner s = new Scanner(System.in);
    System.out.println("请输入");
    String word = s.next();
    System.out.println("您输入的是"+word);
}

控制语句

条件控制语句

if语句

if(条件表达式){表达式返回true,执行此条语句块}

if(条件表达式){表达式返回true,执行此条语句块}
else{表达式返回false,执行此条语句块}

if(条件表达式){表达式返回true,执行此条语句块}
else if(条件表达式){表达式为true,执行此条语句块}
else{表达式返回false,执行此条语句块}

if(条件表达式)表达式为true,执行此条语句
仅输出if后一行,仅作用于紧挨的一行

代码示例

 public static void main(String[] args){
        Scanner day = new Scanner(System.in);
        System.out.println("请输入一个1-7之间的整数,自动判断今天是周几");
        int Day = day.nextInt();
        if (Day==1){
            System.out.println("今天是星期一");

        }else if (Day==2){
            System.out.println("今天是星期二");

        }else if (Day==3){
            System.out.println("今天是星期三");

        }else if (Day==4){
            System.out.println("今天是星期四");

        }else if (Day==5){
            System.out.println("今天是星期五");

        }else if (Day==6){
            System.out.println("今天是星期六");

        }else if (Day==7){
            System.out.println("今天是星期七");

        }else{
            System.out.println("您输入的值有误");
        }
    }

switch语句

多分支选择语句,根据表达式的值来执行多个操作中的一个.

语法格式:
switch(表达式){
		case value1:语句序列;
			[break];
		......
        case valueN:语句序列;
        	[break];
        [default:缺省语句;]
}

表达式可以是byte、short、int、char、枚举类型。JDK7以后，可以使用String类型；

注意：case语句后只能使用常量表达式；case后的值不能重复；或case语句块灭有break语句，它将一直执行后面的case语句，直至遇见break；当所有的case都不匹配时，执行default语句。

示例代码

public static  void main(String[] args){
        System.out.println("请输入月份1-12月");

        Scanner data = new Scanner(System.in);

        int month = data.nextInt();


        switch (month){
            case 1:
                System.out.println("冬季");
                break;
            case 2:
                System.out.println("冬季");
                break;
            case 3:
                System.out.println("春季");
                break;
            case 4:
                System.out.println("春季");
                break;
            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:
                System.out.println("秋季");
                break;
            case 10:
                System.out.println("秋季");
                break;
            case 11:
                System.out.println("秋季");
                break;
            case 12:
                System.out.println("冬季");
                break;

            default:
                System.out.println("您输入的数据不合法");
        }
}

循环语句

功能：在某些条件满足的情况下，反复执行特定代码的功能。

循环体的四个组成部分：

循环变量的初始化；
循环条件部分；
循环体部分；
循环变量的更新。

循环语句分类：

while循环；
do/while循环；
for循环。

while循环

语句形式：while（逻辑表达式）{语句；…}

执行过程：先判断逻辑表达式的值。若为true，则执行后面的语句，然后再次判断条件并反复执行，直到条件不成立为止。

代码示例

// 用while 循环，计算1~100 之间所有5 的倍数的个数,以及和
         int i = 1,j = 0,sum=0;
        while (i<=100){
            if (i%5==0){
                j++;
                sum += i;
            }
            i++;
        }
        System.out.println("倍数有"+j+"个");
        System.out.println("倍数和为"+sum);

do while循环

语句形式：do{语句；…}while（逻辑表达式）；

执行过程:先执行语句,再判断逻辑表达式的值,若为true再执行语句,否则结束循环。

// 用do while 循环，计算1~100 之间所有5 的倍数的个数,以及和
       int i = 1,j = 0,sum=0;
       do {
           if (i%5==0){
               j++;
               sum+=i;
           }
           i++;
       }while (i<=100);
       System.out.println("倍数有"+j+"个");
       System.out.println("倍数和为"+sum);
   }

for循环语句

语句形式:for(表达式1;表达式2;表达式3){语句;…;}

执行过程:首先计算表达式1,接着计算表达式2,若表达式2的值=true,则执行循环语句,接着计算表达式3,再判断表达式2的值,依次重复下去,直到表达式2的值=false。

    public static void main(String[] args){
//        一直青蛙在一口11米深的井底向上爬，白天向上爬3米，晚上向下滑2米，总共需要几天可以爬出.
        int i=0,j=0,sum=0;
        for (i=0;i<12;j++){
            i = i +3;
            if (i<11) {
                i = i-2;
            }else {
                break;
            }
        }
        System.out.println(i);
    }

break和continue语句

break语句用于终止某个语句块的执行。用于循环语句体中，可以强行退出循环；例如：

int stop=4;
for(int=1;i<=10;i++){
	//当i=stop时,退出循环
	if(i==stop){
			break;
	}
	System.out.println("i="+i);
}

continue语句用在循环语句体中,用于终止某次循环过程,跳过循环体中continue语句下面未执行的循环,开始下一次循环过程;例如:

int skip = 4;
for (int i=1;i<=5;i++){
	//当i=skip,跳过当次循环
	if(i==skip){
	continue;
	}
	System.out.println("i="+1);
}

循环嵌套

外层循环 / 内层循环

若需要从多层循环跳出,则需要使用标签,定义一个标签:如label(自定义),然后在需要跳出的地方,用break label即可。

Java中的方法

Java的方法类似于其它语言中的函数，方法是解决一类问题的有序组成。

方法在程序中被创建，声明格式：

[访问权限修饰符  修饰符....][返回值类型]方法名(形式参数类型 参数名){
			Java语句;
			[return返回值;]
	}

return 关键字

可以从方法中向调用处返回值

(注意返回值类型,隐式数据类型转换)

可以结束方法的运行,如果在方法中有循环语句也可以使用return结束循环。void中可以有return，结束方法运行，没有值。

示例代码

public class methods {
    public static void main(String[] args){
        //在main方法中,调用play方法
        //创建方法所在类的对象
        methods s = new methods();
        s.play("Jim",'人');
        s.play("Jim",'人');

        //创建方法所在的类,需要注意类型要一样
        int m = s.add(4,5);
        System.out.println(m);
    }
    //static:有就是类(会加载),没有就是方法
    //void:有就是没有返回值
    //play(传参到字符串,传参到字符型)
    public void play(String name,char palyGame){
        System.out.println(name+"打"+palyGame);
    }

    //拥有返回值的方法
    public int add(int a,int b ){
        return a+b;
    }
}