JavaSE编程002《基础语法》

(1).应用程序主类：
一个Java程序必须有一个含有public class void main(String args[])方法，称这个类是应用程序的主类- (2).解释器：
使用Java解释器(java.exe)来解释执行其字节码文件。Java应用程序总是从主类的main方法开始执行。当Java应用程序中有多个类的时候，Java解释器解释执行的类名必须是主类的名字

我的第一个Java程序

案例

package JavaNote;
/*  多行注释：
    2020年3月23日
*/

/**
 * 文本注释
 */

public class HelloWorld {

    // 关键字 private static class .........
    public static void main(String[] args) {
        // 此处是单行注释

        System.out.println("Hello World.......");
    }
}
/*
s/JavaSE_d995f1f1/bin JavaNote.HelloWorld 
Hello World.......
*/

格式化输出

格式控制：

%d	输出int类型数据
%c	输出char类型数据
%f	输出浮点型数据，小数部分最多保留6位
%s	输出字符串数据
%md	输出的int类型数据占m列
%m.nf	输出的浮点型数据占m列，保留n为有效数字

关键字

关键字	含义
abstract	表明类或者成员方法具有抽象属性
assert	断言，用来进行程序调试
boolean	基本数据类型之一，声明布尔类型的关键字
break	提前跳出一个快
byte	基本数局类型之一，字节类型
case	用在switch语句之中，表示其中的一个分支
catch	用在异常处理中，用来捕捉异常
char	基本数据类型之一，字符类型
class	声明一个类
const	保留关键字，没有具体含义
continue	回到一个块的开始处
default	默认，例如，用在switch语句中，表明一个默认的分支
do	用在do-while循环结构中
double	基本数据类型之一，双精度浮点数类型
else	用在条件语句中，表明当条件不成立时的分支
enum	枚举
extends	表明一个类型是另一个类型的子类型，这里常见的类型有类和接口
final	用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量
finally	用于处理异常情况，用来声明一个基本肯定会被执行到的语句块
float	基本数据类型之一，单精度浮点数类型
for	一种循环结构的引导词
goto	保留关键字，没有具体含义
if	条件语句的引导词
implements	表明一个类实现了给定的接口
import	表明要访问指定的类或包
instanceof	用来测试一个对象是否是指定类型的实例对象
int	基本数据类型之一，整数类型
interface	接口
long	基本数据类型之一，长整数类型
native	用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
new	用来创建新实例对象
package	包
private	一种访问控制方式：私用模式
protected	一种访问控制方式：保护模式
public	一种访问控制方式：共用模式
return	从成员方法中返回数据
short	基本数据类型之一,短整数类型
static	表明具有静态属性
strictfp	用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范 [1]
super	表明当前对象的父类型的引用或者父类型的构造方法
switch	分支语句结构的引导词
synchronized	表明一段代码需要同步执行
this	指向当前实例对象的引用
throw	抛出一个异常
throws	声明在当前定义的成员方法中所有需要抛出的异常
transient	声明不用序列化的成员域
try	尝试一个可能抛出异常的程序块
void	声明当前成员方法没有返回值
volatile	表明两个或者多个变量必须同步地发生变化
while	用在循环结构中

标识符、变量类型

package JavaNote;

//类名命名规则：大驼峰
public class JavaLearningNote001{

    public static void main(final String[] args) {
        // 对变量进行命名使用标识符（变量命名规则，小驼峰）
        // 申明变量类型为String,int 等等........
        String name = "JavaSE";
        int age = 18;

        //输出上边定义的标识符
        System.out.println(name);

        // Java中的数据类型
        // 基本数据类型
        int grade = 89;
        double balance = 55.9;

        // 引用型数据类型:数组，类，方法等等....
        int [][] a = new int[2][3];
        put();;

    }

    public static void put(){
        System.out.println("我是一个方法.......");
    }
    
}

基本数据类型

整数类型

int类型，byte类型，short类型，long类型
在这四种主句类型中，int和long可以定义常量和变量两种，byte和short在Java中暂时不存在常量表示。
int类型定义常量时：123，5000(十进制)，077(八进制)，0x3ABC(十六进制)
long类型定义常量时：采用后缀L来表示，如108L(十进制)，07123L(八进制)，0x3ABCL(十六进制)
而要使用某一个类型定义变量时，只需要直接使用其关键字申明即可。

字符类型

常量直接定义：‘a’,’!’,’?’,‘你好’,'78’等等
变量：使用char关键字申明

浮点类型(其分为单进度float和双精度double)：
常量：
单精度：453.5439f,21379.987F,231.0f(小数表示法),2e40f(2乘10的40次方)，常量必须使用后缀f,F. 双精度：2389.539d,2318908.987,0.05(小数表示),1e-90(1乘10的-90次方)，可以不使用后缀d,D
变量：
与其他类型一样，直接使用其关键字申明即可
各个数据类型从有效长度

public class Page003 {
	public static void main(String args[]) {
		System.out.println("byte的取值范围:"+Byte.MIN_VALUE+"至"+Byte.MAX_VALUE);
		System.out.println("short的取值范围:"+Short.MIN_VALUE+"至"+Short.MAX_VALUE);
		System.out.println("int的取值范围:"+Integer.MIN_VALUE+"至"+Integer.MAX_VALUE);
		System.out.println("long的取值范围:"+Long.MIN_VALUE+"至"+Long.MAX_VALUE);
		System.out.println("float的取值范围:"+Float.MIN_VALUE+"至"+Float.MAX_VALUE);
		System.out.println("double的取值范围:"+Double.MIN_VALUE+"至"+Double.MAX_VALUE);
	}
}
/*
byte的取值范围:-128至127
short的取值范围:-32768至32767
int的取值范围:-2147483648至2147483647
long的取值范围:-9223372036854775808至9223372036854775807
float的取值范围:1.4E-45至3.4028235E38
double的取值范围:4.9E-324至1.7976931348623157E308
 */

运算符

算术运算符

\ + - * / % ++ –
"+"有几种用法:拼接字符串；数值数据做加法
自增、自减运算符是++、–是单目运算符。可以放在操作圆之前，也可以放在操作元之后，操作元必须是一个整型或者浮点型变量，作用是使变量的值加1或者减1。
++x(–x)表示在使用x之前，先使x的值增(减)1.
x++(x–)表示在使用x之后，使x的值增(减)1.

关系运算符(比较)

== != > < >= <=
需要注意什么类型的数据使用什么运算符

赋值运算符

=
+= -= *= /= %= 特点

逻辑运算符

& && | || ! , 注意 & | 可以用作逻辑运算,还可以用作什么(位运算)?
逻辑值与逻辑值之间的运算 true false
&& || !(取反) (主要使用)
& &&(短路与也是逻辑运算) 区别
相同点:
当左右的表达式值都为true 结果为true
不同点:
& 当表达式中出现false,还会继续执行后面的表达式
&& 当表达式中出现false,就不会执行后面的内容(遇假则假)
| ||
相同点:
只要表达式中有一个true,结果就为true.
不同点:
| 当表达式中出现true,还会继续执行后面的表达式
|| 当表达式中出现true,就不会执行后面的内容(遇真则真)

位运算:按位运算位:二进制bit位

& | ~ ^ >> << >>>
& ! 左右为逻辑值,则进行逻辑运算

运算符	含义
&	按位与
\|	按位或
~	按位非
^	按位异或
<<	左位移运算符
>>	右位移运算符
> > >	无符号右移运算符

条件运算符(三目运算)

x?y:z
x 是一个条件表达式
x==true 则执行y表达式
x==false 则执行z表达式

package JavaNote;

import java.util.Scanner;

public class JavaLearningNote002{

    public static void main(String[] args) {
        // 实现基本的运算：用户输入一个半径，计算元的面积
        Scanner scanner = new Scanner(System.in);

        //定义一个圆的半径
        System.out.println("输入圆的半径");
        double r = scanner.nextDouble();

        // 开始计算圆的面积
        // 定义圆的面积变量:引用了Java自带的数学库Math
        double s = Math.PI * r * r;

        // 输出圆的面积   输出内容使用+进行拼接
        System.out.println("圆的面积为"+s);
    }
}

/*
e37bbba6cdb539eaab/redhat.java/jdt_ws/JavaSE_d995f1f1/bin JavaNote.JavaLearningNote002 
输入圆的半径
6
圆的面积为113.09733552923255
*/

条件空值语句

switch … case …开关语句的使用

案例一

/*
switch (表达式)
{
	case 常量值1:
		若干个语句
		break；
	case 常量值2:
		若干个语句
		break；
	case 常量值n:
		若干个语句
		break；
	default:
		若干语句
}
*/
import java.util.*;
public class Page001 {
	public static void main(String args[]) {
		int number = 0;
		System.out.println("输入正整数(按enter确定):");
		Scanner reader = new Scanner(System.in);
		number = reader.nextInt();
		switch(number) {
		case 9:
		case 131:
		case 12:
			System.out.println(number+"是三等奖");
			break;
		case 209:
		case 596:
		case 27:
			System.out.println(number+"是二等奖");
			break;
		case 875:
		case 316:
		case 59:
			System.out.println(number+"是一等奖");
		default:
			System.out.println(number+"未中奖");
		}
	}
}
/*
输入正整数(按enter确定):
27
27是二等奖
*/

案例二


package JavaNote;

import java.util.Scanner;

public class Page002{

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        
        // switch ... case 语句
        // 用户输入一个字符，给出相应的评价
        System.out.println("输入一个字符");
        String grade = scanner.next();
        
        // 使用开关语句进行判断
        switch(grade){
            case "A":
                System.out.println("A");
                break;
            case "B":
                System.out.println("B");
                break;
            case "C":
                System.out.println("C");
                break;
            case "D":
                System.out.println("D");
                break;
            default:
                System.out.println("都不满足条件");
                break;
        }
    }
}

/*
superme@ubuntu:~/JavaSE$  cd /home/superme/JavaSE ; /usr/local/jdk1.8/bin/java -Dfile.encoding=UTF-8 -cp /home/superme/.config/Code/User/workspaceStorage/fa5e4cfe4092c2e37bbba6cdb539eaab/redhat.java/jdt_ws/JavaSE_d995f1f1/bin JavaNote.Page002 
输入一个字符
B
B
*/

for循环 while循环的使用

案例一

package JavaNote;

import java.util.Random;
import java.util.Scanner;

public class CirculationPricate{

    public static void main(String[] args) {
        
        

        // for循环使用
        // 打印乘法表
        for (int i=1;i<10;i++){

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

                System.out.print(j+" * "+i+" = "+(i*j)+" ");
            }
        System.out.println();
        }

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

        // white循环的使用
        Scanner Scanner = new Scanner(System.in);
        // 产生一个随机数猜数字
        Random random = new Random();
        // 产生随机数
        int number = random.nextInt(10);
        System.out.println(number);

        //用户输入要猜的数字
        System.out.println("输入一个数字.");
        int inputNumber = Scanner.nextInt();
        while (number != inputNumber){
            System.out.println("猜错了，重新输入..");
            inputNumber = Scanner.nextInt();
        }
        System.out.println("猜对了.....");

    }
}


/*
superme@ubuntu:~/JavaSE$  /usr/local/jdk1.8/bin/java -Dfile.encoding=UTF-8 -cp /home/superme/.config/Code/User/workspaceStorage/fa5e4cfe4092c2e37bbba6cdb539eaab/redhat.java/jdt_ws/JavaSE_d995f1f1/bin JavaNote.CirculationPricate 
1 * 1 = 1 
1 * 2 = 2 2 * 2 = 4 
1 * 3 = 3 2 * 3 = 6 3 * 3 = 9 
1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16 
1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25 
1 * 6 = 6 2 * 6 = 12 3 * 6 = 18 4 * 6 = 24 5 * 6 = 30 6 * 6 = 36 
1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6 * 7 = 42 7 * 7 = 49 
1 * 8 = 8 2 * 8 = 16 3 * 8 = 24 4 * 8 = 32 5 * 8 = 40 6 * 8 = 48 7 * 8 = 56 8 * 8 = 64 
1 * 9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81 
----------------------------------------------------
5
输入一个数字.
4
猜错了，重新输入..
5
猜对了.....
superme@ubuntu:~/JavaSE$ ^C
superme@ubuntu:~/JavaSE$ 
*/

案例二

//for循环打印1000以内的完数

public class CirculationPricate001 {
	public static void main(String args[]) {
		int i = 1;
		int j = 1;
		for (i = 1;i < 1000;i++) {              //保证循环次数小于1000
			int num = 0;
			for(j = 1;j < i;j++) {          
				if (i % j ==0) {                //寻找因数
					num += j;                   //将所有因数累加，方便下一步判断
				}
			}if (num == i) {                    //判断是否满足完数的条件
				System.out.println(i+"是完数！");
			}
		}
	}
}
/*
6是完数！
28是完数！
496是完数！
*/

案例三

//使用for循环计算1+1/2!+1/3!+....的前20项和


public class CirculationPricate002{
	public static void main(String arg[]){
		double sum = 0,item = 1;
		int i,n = 20;
		for (i = 2;i < n;i++) {
			sum += item;
			item = item*(1.0/i);
		}
		System.out.println("sum = "+sum);
	}
}
//sum = 1.7182818284590455

案例四

do{
	若干语句
}while(表达式)

实例operation5.java:
//和使用do-while循环计算1+1/2!+1/3!+....的前20项和

public class operation5{
	public static void main(String args[]) {
		double sum = 0,itme = 1;
		int i = 1;
		do {
			sum += itme;
			i += 1;
			itme = itme*(1.0/i);
		}while(i<20);
		System.out.println("sum = "+sum);
	}
}
//sum = 1.7182818284590455

方法

package JavaNote;

public class JavaMethod{

    public static void main(String[] args) {
        method1();
        System.out.println("-------------------------------------------");
        method2();
        System.out.println("-------------------------------------------");
        method3();
    }

    // 定义三个方法
    public static void method1(){
        System.out.println("我是方法1..................");
    }

    public static void method2(){
        System.out.println("我是方法2..................");
    }

    public static void method3(){
        System.out.println("我是方法3..................");
    }
}
/*
superme@ubuntu:~/JavaSE$  cd /home/superme/JavaSE ; /usr/local/jdk1.8/bin/java -Dfile.encoding=UTF-8 -cp /home/superme/.config/Code/User/workspaceStorage/fa5e4cfe4092c2e37bbba6cdb539eaab/redhat.java/jdt_ws/JavaSE_d995f1f1/bin JavaNote.JavaMethod 
我是方法1..................
-------------------------------------------
我是方法2..................
-------------------------------------------
我是方法3..................
superme@ubuntu:~/JavaSE$ 
*/

十一丶

发布了63 篇原创文章 · 获赞 1 · 访问量 2010

私信关注