Java基本语法

一、基本框架

　　1）概念

　　一个Java程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作

对象（object）：代表现实世界中可以明确标识的一个实体，存在独特的标识、状态和行为。例如，一条鱼是一个对象，它的状态有：颜色、品种；行为有：漫游、鱼跃等。
类（class）：是创建对象的模板，用于描述一类对象的行为和状态。
方法：方法就是行为，一个类可以有很多方法。

public class Welcome {        //类
public static void main(String[] args) {    //主方法
    System.out.println("welcome to java!"); //输出结果
    
//  System.out.print()；//不会换行
//  System.out.println()；//会在输出完数据之后自动输出一个换行符
}
}

　　注意：①每行必须以 ; 结束

　　　　　②关键字或保留字不能在程序中作为标识符

　　　　　③注释方法： // -单行注释

　　　　　　　　　　　/**/ -多行注释

　　　　　④块：通过 { } 把一些程序语句括起来形成一个块，块是可以嵌套的

　　2）编译与执行

　　1、JDK

　　JDK，全称是 Java Development Kit ，即 Java 开发包，是开发 Java 程序需要的工具包，通常，JDK 中包含了相应版本的 JRE。

　　开发者编写的 Java 源程序是.java结尾的文件，JDK 可以将其编译成.class结尾的文件（这就相当于是某种意义上的 “机器语言”

了），从而在 JRE 上执行。

　　编译：

    javac Welcome.java

　　2、JRE

　　JRE，全称是 Java Runtime Environment，即 Java 运行时环境，是 Java 运行时需要安装的环境，这个环境中带有 JVM 。一台机器上有 JRE，那么就能运行 Java 程序了。

JRE 可以说是承载了 JVM 的具体环境。不同的硬件平台上有不同的 JRE，但不同的 JRE 都承载着相同的 JVM。

　　3、JVM

　　JVM，全称是 Java Virtual Machine，即 Java 虚拟机，Java 程序最终运行需要依赖 JVM， Java 程序之所以支持跨平台，“一次编写，处处运行”，正是因为 JVM 。

　　执行：

    java Welcome

　　注意：每个java程序都必须先编译再执行。

　　3）Java特性

简单（simple）；
面向对象（object oriented）；
分布式（distributed）；
解释型（interpreted）；
鲁棒（robust）；
安全（secure）；
体系结构中立（architectural neutral）；
可移植（portable）；
高性能（high performance）；
多线程（multithreaded）；
动态性（dynamic）。

二、命名习惯　

　　　①均不能以下划线或美元符号开始，也不能以下划线或美元符号结束

　　　　反例： _name / __name / $Object / name_ / name$ / Object$

　　 ②严禁使用拼音与英文混合，更不允许直接使用中文的方式

　　　　反例： DaZhePromotion [打折] / getPingfenByName() [评分] / int 某变量 = 3

　　 ③类名使用UpperCamelCase风格，必须遵从驼峰形式

　　　　正例：MarcoPolo / UserDO / XmlService / TcpUdpDeal / TaPromotion

　　　④方法名、参数名、成员变量、局部变量都统一使用 lowerCamelCase 风格，必须遵从驼峰形式。

　　　　正例：localValue / getHttpMessage() / inputUserId

　　　⑤常量命名全部大写，单词间用下划线隔开。

　　　　正例：例如，常量PI和MAX_VALUE

　　　⑥抽象类命名使用 Abstract 或 Base 开头；异常类命名使用 Exception 结尾；测试类命名以它要测试的类的名称开始，以 Test 结尾

　　　⑦包名统一使用小写，点分隔符之间有且仅有一个自然语义的英语单词

三、基本输入输出

1）输入

　　Java Scanner类：获取命令行输入的方法

　　使用Scanner类需要导入包：import java.util.Scanner;

import java.util.Scanner; //明确导入

public class ScannerDemo {

    public static void main(String[] args) {
        
        //实例化一个Scanner类的scanner对象，System.in表示标准输入设备，默认设备是键盘
        Scanner input = new Scanner(System.in); 
        
        //以next方式接收字符串
        String string = input.next();   //接收字符串类型的数据
        int number = input.nextInt();　　//接受int类型的数据
            
        System.out.println("输入的string为:" + string);   //输出变量string
        System.out.println("输入的number为:" + number);   //输出number 
        input.close(); //释放资源
    }
}

　　从键盘读取值：以next方式接受数据，不同的类型不同写法，包含下面的情况：

2）输出

　　System.out表示标准输出设备，默认设备是显示器。

　　使用System.out所包含的方法无需导入额外的包。

　　主要包含三个方法：

　　①System.out.print()；//纯输出

　　②System.out.println()；//会在输出完数据之后自动输出一个换行符

　　③System.out.printf(string format,args)；  //格式化输出

　　　　--string format

　　　　　　%d 整型： %5d 最大5位，不够补空格

　　　　　　%f 浮点型： %.2f 两位小数
　　　　　　　　　　　　%5.2f 整数位最大5位宽度，小数位2位，不够前面补空格

　　　　　　%b 布尔型： true/false %5b（最大5位宽度）

　　　　　　%s 字符型：%10s 10位宽度

四、变量与常量

1）常量

　　常量表示从不改变的永久数据。

　　常量必须在同一条语句中声明和赋值，单词final是声明常量的java关键字。

　　//声明常量
　　final 数据类型  常量名 =  值；

　　好处：不用重复输入同一个值；若需修改常量值，只需要在源代码的一个地方做修改

2）变量

　　1、概念：通俗的说，变量就是一个存储容器，容器中存放的“东西”可以进行改变。

　　2、定义变量的几种方式

　　　　①先声明后赋值

　　//声明： 变量数据类型  变量名    
    　　int  number;
　　//赋值： 变量名 = 值
   　　 number = 15;

　　　　②一步完成声明、赋值

　　//变量数据类型 变量名  =  值
       int  number  =  15;

　　　　③多个变量的初始化，可以一步完成

　　int num1 = 3,num2 = 23;   //中间用英文版逗号（ , ）隔开

五、数据类型

1）整型

　　注意：给long赋值时，因为整数默认是int类型，要转换为long类型的值，后面加上l或L

　　进制转换：（输出结果是十进制）

　　　　①默认进制是10进制

　　　　②二进制：以0B 或 0b开头

　　　　③八进制：以0开头

　　　　④十六进制：以0X 或 0x开头

　　//示例
　　int num1 = 1200;  //十进制
　　System.out.println(num1);
        
　　int num2 = 0B10010011;  //二进制
　　System.out.println("0B10010011 = " + num2); 
        
　　int num3 = 07265;  //八进制
　　System.out.println("07265 = " + num3);

　　int num4 = 0xAB7E; //十六进制
　　System.out.println("0xAB7E = " + num4);

　　数值类型转换

　　①自动类型转换(小范围转大范围)

　　　　byte short char =>> int =>> long = >> float =>> double

　　　　注意：当byte short char 之间进行运算时结果属于int型；

　　　　　　　boolean类型不可以转换为其它的数据类型。

　　②强制类型转换（大范围转小范围）

　　　　使用： "(目标数据类型)" 符号

　　　　格式：小的数据类型 = (小的数据类型) 大的数据类型

2）浮点型（小数型）

　　1、单精度（float）：占用存储空间（4字节）、表数范围（ -2 ^ 128 ~ +2 ^ 128）

　　2、双精度（double）：8字节 -2 ^ 1024 ~ +2 ^ 1024（默认浮点型）

　　注意：在表示float 类型时，必须加上f 或者F；

　　　　两者都不能精确的表示一个数，而是表示无限接近于这个数；

　　　　使用BigDecimal可以更精确的表示浮点数。

3）布尔型

　　boolean 值：true/false

4）字符型

　　1、char型

　　占用存储空间（单个字符即2字节），表数范围（0 ~ 2 ^ 16 -1）

　　char letter = 'A'; 
　　char letter = 'abc';  //错误定义，char型表示单个字符

　　char numChar = '5';

　　unicode码和ASCII码

　　unicode码：一个16位Unicode码占两个字节，用以\u开头的4位16进制数表示；

　　　　　　　　范围从'\u0000'到'\uFFFF。

　　ASCII码：所有大小写字母、数字、标点符号和控制符的8位编码表。

　　Unicode码包括ASCII码，从'\u0000'到'\u007F‘对应128个ASCII字符。

　　char letter1 = 'Y'; //ASCII= 89
　　char letter2 = 'c'; //ASCII=99
　　char letter3 = '@';
　　char letter4 = '\u1010';
        
　　System.out.println(letter1+letter2); //输出结果位int型,188
　　System.out.println(letter1 +""+ letter2); // Yc
        
　　System.out.println(letter3<letter4); //true

　　转义序列表

//输出：y:"nobody can stop me now!"
System.out.println("y:\"nobody can stop me now!\"\n");

/*
 * 需求：显示从2000到2100期间所有的闰年,每行显示10个,之间用制表符分割
 * 
 * 分析：
 * 1、定义一个line变量，初始化为0
 * 2、利用for循环表示year从2000到2100年数，循环体内为判断闰年语句，每循环到year为闰年时，打印出year并且line加1；
 * 3、当line等于12时，进行换行
 * 闰年条件：
 *   ①year % 4 == 0 && year % 100 != 0
 *   ②year % 400 == 0
 * 
 * @author longhj
 * */public class Work9Years {
    public static void main(String[] args) {
        int line = 0;
        for(int year = 2000;year <= 2100; year++) {
            if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
                System.out.print(year + "\t");  //横向制表符
                line++;
            }
            if(line == 12) {
                System.out.print("\n"); //换行
                line = 0;
            }
        }
    }
}

　character类的常用方法

    //character类的常用方法
　　char letter = 'y';
　　char numChar = '5';
　　int number = 5;
        
　　System.out.printf("%s是否是一个数字：%b\r\n",number,Character.isDigit(number));
　　System.out.printf("%s是否是一个字母：%b\r\n",letter,Character.isLetter(letter));
　　System.out.printf("%s是否是一个数字：%b\r\n",numChar,Character.isDigit(letter));
　　System.out.printf("%s是否是一个字母或数字：%b\r\n",letter,Character.isLetterOrDigit(letter));
        
　　System.out.printf("%s是否是一个小写字母：%b\r\n",letter,Character.isLowerCase(letter));
　　System.out.printf("%s是否是一个大写字母：%b\r\n",letter,Character.isUpperCase(letter));
　　System.out.printf("返回%s的大写形式：%s\r\n",letter,Character.toUpperCase(letter));
　　System.out.printf("返回%s的小写形式：%s\r\n",letter,Character.toLowerCase(letter));

2、string型

　　char只能表示一个字符，而string能够表示一串字符

　　例：string str1 = "Good luck！";　　

　　String类型不是基本数据类型，而是引用类型。这里str1是一个引用变量，它引用一个内容为Good luck！的字符串对象。

　　①常见操作

　　str1.length()：长度

　　str1.concat(str2)：连接str1与str2

　　str1.charAt(int index)：指定索引位置的字符，索引从0开始

　　str1.toUpperCase()：返回大写形式

　　str1.toLowerCase()：返回小写形式

　　str1.trim()：返回str1去掉两边空白字符的新字符串

    //字符串常见操作
String str1 = "Nobody Can Stop Me Now!";
String str2 = "abcde";
String str3 = "  opqr sv ";
        
System.out.printf("\"%s\"的长度为：%s\r\n",str1,str1.length());
System.out.printf("str2与str3连接：%s\r\n",str2.concat(str3));
System.out.printf("str2索引为2的字母：%s\r\n" , str2.charAt(2));
System.out.printf("str1所有字母大写：%s\r\n" , str1.toUpperCase());
        
System.out.printf("\"%s\"的长度为：%s\r\n",str3,str3.length());
System.out.printf("str3去掉两边空白字符:%s\r\n" , str3.trim());

　　②字符比较

　　.equals() ：如果相等，返回true

　　.equalsIgnoreCase() ：忽略大小写

　　.compareTo()

　　.startsWith("***") ：(是否以指定字符串开头)

　　.endsWith("***") ：是否以特定的字符串结尾

　　.contains("***") ：是否包含

//字符比较
String str4 = "Cookies";
String str5 = "ycfamily";
        
System.out.println(str4.equals(str5));//相等为true，反之false 
System.out.println(str4.equalsIgnoreCase("CooKieS"));//忽略大小写
        
System.out.println(str4.compareTo(str5));//返回小于0的整数  对应的ASCII码之和相减：srt4-str5
System.out.println(str5.compareTo(str4));//返回大于0的整数
System.out.println(str5.compareTo("ycfamily"));//返回0
        
System.out.println(str5.startsWith("yc"));//是否以yc开头
System.out.println(str5.endsWith("yc")); //是否以yc结尾
System.out.println(str5.contains("yc")); //是否包含yc

　　③字符截取

　　.substring(index) //从指定位置开始截取到最后

　　.substring（int begin,int end） //从begin开始截取到end

　　④字符查找

　　.indexoOf("a") //返回第一次出现a的索引位置

　　.lastIndexOf("a") //返回最后一次出现a的索引位置

String str6 = "it'sanotawhataiachose";
System.out.println(str6.length()); //21
                
//字符截取
System.out.println(str6.substring(5));//notawhataiachose
System.out.println(str6.substring(8,15)); //awhatai
        
//字符查找
System.out.println(str6.indexOf("a")); //4
System.out.println(str6.lastIndexOf("a")); //15

　　3、字符与数值之间的转换

　　①string型转换为数值型

　　Byte.parseByte(numString)：转为byte型

　　Short.parseShort(numString)：转为short型

　　Integer.parseInt(numString)：转为int型

　　Long.parseLong(numString)：转为long型

　　Float.parseFloat(numString)：转为float型

　　Double.parseDouble(numString)：转为double型

　　②转换时可以指定进制转换

　　③将数值型转换为string型：使用字符串拼接一个空串即可

//字符与数值之间转换
//string转数值型
String numString = "100";
System.out.println(numString + 10); //10010
System.out.println(Byte.parseByte(numString) + 10); //110
        
short shortNumber = Short.parseShort(numString);
System.out.println(shortNumber + 10);  //110
        
System.out.println(Integer.parseInt(numString)+10); //110
System.out.println(Long.parseLong(numString)+10); //110
System.out.println(Float.parseFloat(numString)); //100.0
System.out.println(Double.parseDouble(numString)+"\r\n"); //100.0
        
//指定进制转换
int num = Integer.parseInt("00110011",2);
System.out.println(num); //51
num = Integer.parseInt("A23C",16);
System.out.println(num); //41532
        
//数值型转string
int num2 = 23;
String str = num2 + "";
System.out.println(str); //23

六、运算符

1）算术运算符

　　注意：①整数之间做除法时，只保留整数部分而舍弃小数部分。如：5 / 2 = 2

　　　　 ②++、-- 还要区分前后：前++（先自增1，再运算）、后++（先运算，再自增1）；前--（先自减1，再运算），后--（先运算，再自减1）

/* 运算符练习
 *
 * @author longhj
 * */
package edu.practice_1024;
public class Work1 {
public static void main(String[] args) {
    double a = 3, b = 4;
    //练1
    System.out.println("练1");
    //(a++)/3+(--b)*2-(a--)%6+(b++)*3-(b--)
　　　　a++ /3  >>>>>  1,a=4, result=1
　　　　--b *2  >>>>>  b=3,6, result=1+6=7
　　　　a-- %6  >>>>>  4,a=3, result=7-4=3
　　　　b++ *3  >>>>>  9,b=4, result=3+9=12
　　　　b--     >>>>>  4,b=3, result=12-4=8
    System.out.println((a++)/3+(--b)*2-(a--)%6+(b++)*3-(b--)); //8
    
    //(++b)*2-(a--)%4+(a++)*5-(--b)/2+(--a)
    a=3;b=4;
    System.out.println((++b)*2-(a--)%4+(a++)*5-(--b)/2+(--a)); //17

　　 //练2
    System.out.println("练2");
    //a>b&(a++)>b&(--b)<a&(b++)>(a--)
    a=3;b=4;
    System.out.println(a>b&(a++)>b&(--b)<a&(b++)>(a--)); //false
    //b<=a|(b--)>(--a)|(++b)!=(a++)|(b--)==(a--)
    a=3;b=4;
    System.out.println(b<=a|(b--)>(--a)|(++b)!=(a++)|(b--)==(a--)); //true
}
}

/*
*需求：用户输入四位会员号：计算四位会员号的之和。
* 
* 分析：
* 1、输入会员号
* 2、分解会员号
* 3、计算各数字之和
*
*@author longhj
**/
package edu.practice_1024;
import java.util.Scanner;
public class Work4 {
    public static void main(String[] args) {
        int custNo; //定义会员号
        System.out.println("请输入4位会员卡号");
        Scanner input=new Scanner(System.in);
        //输入会员卡号
        custNo=input.nextInt();
        System.out.println("会员卡号是："+custNo);
        
        // 利用“/” 和 “%” 运算符获得每位数字
        int g=custNo%10; //分解获得个位数
        int s=custNo/10%10; //分解获得十位数
        int b=custNo/100%10; //分解获得百位数
        int q=custNo/1000; //分解获得千位数
        System.out.println("千位数："+q+",百位数："+b+",十位数："+s+", 个位数："+g);
        //利用“+” 运算符计算各位数字之和
        int sum=g+s+b+q;
        System.out.println("会员卡号"+custNo+"各位之和："+sum);
        input.close();
    
    }
}

2）关系运算符　　

3）逻辑运算符

　　① 与（&&、&）：全真为真，有假则假

　　　　区别：&&会进行短路运算，&不会；&可以进行进位运算，&&不可以；若要进行逻辑与运算，推荐使用&&

　　② 或（ ||、| ）：有真为真，全假则假

　　　　区别：|| 会进行短路运算，| 不会；| 可以进行进位运算，|| 不可以；若要进行逻辑与运算，推荐使用 ||

　　③ 非（！）：结果取反

　　④ 异或（^）：相同为假，不同为真

　　　　true ^ true => false

　　　　false ^ false => false

　　　　true ^ false => true

/*
 * 需求：判断给定的某个年份是否是闰年
 * 
 * 分析：
 * 1、输入年份
 * 2、判断是否为闰年的条件
 * 条件一：year%400==0
 * 条件二：year % 4 == 0 && year % 100 != 0
 * 
 * @author longhj*/

package edu.practice_1025;

import java.util.Scanner;

public class Work10 {

    public static void main(String[] args) {
        //输入年份
        int year;
        Scanner in = new Scanner(System.in);
        System.out.println("请输入一个年份：");
        year = in.nextInt();
        
        //判断输入的年份是否为闰年
        if (year % 400 == 0 ||(year % 4 == 0 && year % 100 != 0)){   
            System.out.println(year + "年是闰年。");
        }
        else {  
            System.out.println(year + "年不是闰年。");
        }
        in.close();
    }
}

posted on 2023-10-30 10:30 L0ngyc 阅读(63) 评论(0) 收藏举报

刷新页面返回顶部

longhj