java周记(第一周)

一.java的概况(初识java)

1.什么是Java

Java语言是美国Sun公司（StanfordUniversityNetwork），在1995年推出的高级的编程语言。所谓编
程语言，是计算机的语言，人们可以使用编程语言对计算机下达命令，让计算机完成人们需要的功能。
詹姆斯·高斯林（James Gosling）1977年获得了加拿大卡尔加里大学计算机科学学士学位，1983年获
得了美国卡内基梅隆大学计算机科学博士学位，毕业后到IBM工作，设计IBM第一代工作站NeWS系
统，但不受重视。后来转至Sun公司，1990年，与Patrick，Naughton和Mike Sheridan等人合作“绿色
计划”，后来发展一套语言做“Oak”，1995后改名为Java。

2.java能干什么

Java语言主要应用在互联网程序的开发领域。常见的互联网程序比如天猫、京东、物流系统、网银系统等，以及服务器后台处理大数据的存储、查询、数据挖掘等也有很多应用

3.java语言平台版本

JAVAEE(企业开发)  JAVAME  JAVASE

4.Java语言特点

简单性  解释性  面向对象  高性能  分布式处理  多线程  健壮性  动态  结构中立  安全性  开源  跨平台

5.java开发环境搭建

5.1JVM

JVM(Java Virtual Machine): Java虚拟机，简称JVM，是运行所有Java程序的假想计算机，是Java
程序的运行环境

5.2JRE

JRE（Java Runtime Environment）:是Java程序的运行时环境，包含JVM和运行时所需要的核心类库。

5.3JDK

JDK（Java Development Kit）:是Java程序开发工具包，包含JRE和开发人员使用的工具。

5.4JAVA_HOME环境变量的配置

步骤:1.文件资源管理器 --> 此电脑鼠标右键 --> 选择 属性

        2.选择 高级系统设置 --> 选择 环境变量

        3.点击下方系统变量的 新建 ，创建新的环境变量，变量名输入 JAVA_HOME ，变量值输jdk的安装目录

        4. 选中 Path 环境变量， 双击 或者 点击编辑

        5. 点击 新建 ，键入 %JAVA_HOME%\bin ，必须是英文格式。选中该行，上移到最上方，点击确定

6.main方法

称为主方法。写法是固定格式不可以更改。main方法是程序的入口点或起始点，无论
我们编写多 少程序，JVM在运行的时候，都会从main方法这里开始执行

7.添加注释(为了提高代码阅读性)

7.1单行注释

以 //开头 换行结束

7.2多行注释

以 /* 开头 以*/结束

7.3文档注释

以 /**开头以*/结束

二.java的基本语法

1.java中的基本语法格式

1.1程序包括结构定义和功能执行，每条语句都以;结尾
1.2严格区分大小写
1.3排版问题
1.4一个连续的字符串不能出现在两行，若字符串太长，则写成两个较短字符串的和

2.java中的关键字(被Java语言赋予特定含义的单词,叫关键字!)

  

1.abstract

• 修饰类：

abstract修饰类，这个类就是抽象类，抽象类中可以有非抽象变量和成员变量，也可以有普通方法、构造方法。但是不能实例化，只能被子类继承。
如果子类不是抽象类，则必须重写父类的抽象方法。

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
    ...
}

• 修饰方法:

abstract修饰方法，这个方法就是抽象方法。抽象方法必须存在于抽象类中。抽象方法不能有具体实现。

abstract public E get(int index);

2.assert

assert表示“断言”，有两种使用方法：

assert 表达式;

若表达式为真，程序继续执行；若表达式为假，则抛出一个AssertionError异常。

assert 表达式:错误信息;

与第一种方法相同，只是异常中带有错误信息。
使用assert时不能在表达式中完成任何程序实际所需的行为（只能做判断）。因为正常发布的代码都是断言无效的，即正常发布的代码中断言语句都不不执行的。

3.boolean

boolean是Java的基本类型之一（默认值false）。只有两个值：true和false。区别C的判断句，Java不能直接使用1和0来表示真假，且boolean类型也不能强转到其他基本类型。

boolean a = true;
boolean b = false;

4.break

1. break在switch中用于跳出switch块，停止switch向下穿透的现象。

case value:expression;
    break;

1. break在循环中用于跳出循环。

while(...){
    ...
    break;
}

1. break也可以在后面接标签，用来跳出一些嵌套比较复杂的循环中。

flag:
for(...){
    for(...){
        break flag;
    }
}

5.byte

byte是Java的基本类型之一（默认值0）。表示8位有符号整数。

范围：-128~127

byte a = 100;

6.case

case用于switch中，用于判断和执行语句。用法：

case 变量值:语句;

若变量值和switch(变量值)
中的变量值相等，就执行后面的语句。执行完后继续执行下一个case语句。

7.catch

catch用于捕获异常。
用法：

catch(异常类型 异常){...}

在try/catch语句块中，catch捕获发生的异常，并应对错误做一些处理。
当catch捕获到异常后，try中执行的语句终止，并跳到catch后的语句中。

                                                                                                 

8.char

char是Java的基本类型之一（默认值\u000）。表示16位、在Unicode编码表中的字符。使用单引号来表示字符常量，例如’A’。

范围：0-65535

char a = 'A';

9.class

class表示类。用于声明一个类。      

[访问控制] (abstract) class 类名 (implements){...}

10.const

const是Java的一个保留关键字，没有实际意义，但是不能用于做变量名（因为被保留作为关键字了）。在C语言中表示常量，类似Java的final。

11.continue

1. continue用于在循环中跳过本次循环。

while(...){
    ...
    continue;
}

1. continue也可以在后面接标签，在一些嵌套比较复杂的循环中跳过一次循环。

flag:
for(...){
    for(...){
        continue flag;
    }
}

12.default

default关键字：

1. 用于switch做默认分支：

default:语句；

1. 用于接口,让接口实现具体的方法：

public interface a{
    default void b(){
        具体方法;
    }
}

default用于接口时，必须要有具体实现。
(API>=24)

13. do

do用于和while组成循环，do/while循环不同于while循环，属于先执行循环体再判断。

do{
	循环体;
}while(...)

14.double

double是Java的基本类型之一（默认值0.0d），表示双精度、64位的浮点数。

double a = 0.1d;

15.else

else用于分支结构中的判断。例如：

if(判断1){
    语句1;
}else if(判断2){
    语句2;
}else{
    语句3;
}

16.enum

enum表示枚举，用于限制变量值的类型，例如：

public enum Alpha (implements 接口){
    (public static final)a,b,c,d
}

规定Color的实例只能为a,b,c,d其中之一。

枚举类中可以有成员变量和方法。

17.extends

extends表示继承。例如：

class 子类 extends父类{}

Java中的继承是单继承，即子类只能有一个直接父类。
除了private，子类可以访问父类的方法和成员变量。

18.final

1. 修饰变量：
   将变量变为常量，在初始化变量后不能再改变值。
2. 修饰方法：
   被final修饰的方法不能被子类重写。
3. 修饰类：
   被final修饰的类不能被继承。

19.finally

finally在try/catch语句块中处理一些后续的工作。例如关闭网络连接和输入输出流等。

• 如果在try/catch中使用return，则finally会撤销这个return，无论如何都会执行finally中的语句。

20.float

float是Java的基本类型之一（默认值0.0f）。表示单精度、32位的浮点数。

float a = 0.1f;

21.for

for用于循环:

for(初始化循环变量; 判断执行条件;更新循环变量){
    语句
}
for(变量:数组){
    语句
}

22.goto

Java中的保留关键字，没有实际意义，但是不能用做变量名。在C中表示无条件跳转语句。

23.if

if用于分支结构中的判断。常与else和else if使用。

if(表达式){语句}

若表达式为真，则执行后面的语句。

24.implements

implements用于接入接口。接上接口的类必须实现接口的抽象方法（可以不实现默认方法和静态方法）。

class A implements B{
    @Override
    do(){
        ...
    }
}

25.import

用于导入包。

import android.content.Intent;

26.instanceof

instanceof用于判断类与对象的关系。例如：

a instanceof b

若a是b的一个实例(或子类对象)，则整个表达式的结果是true，否则结果为false。

27.int

int是Java的基本类型之一（默认值为0）。表示32位、有符号的整数。

范围：[-231,231-1)

int a = 1;

28.interface

interface用于声明一个接口，例如：

public interface A{
    void b();
}

声明a为一个接口，若接上该接口，则必须实现其中的抽象方法b。
接口中的成员变量是static、final、public的。接口中的方法为静态方法或默认方法和静态方法(API>=24)。

29.long

long是Java的基本类型之一（默认值为0L），表示64位、有符号的整数。

范围：[-263,263)

long a = 3216846849646L;

30.native

native可以让Java运行非Java实现的方法。例如c语言，要编译后用javah产生一个.h文件。导入该.h文件并且实现native方法，编译成动态链接库文件。在Java加载动态链接库文件，这个native方法就可以在Java中使用了。

public native void aVoid();

31.new

new用于生成类的实例。

Object a = new Object()；

32.package

package用于规定当前文件的包。

package com.example.zhangyijun.testdefactivity;

33.private

访问控制的一种。
私有的方法和变量只能在本类中访问。类和接口不能为私有。

private int a = 1;
private void b(){
    ...
}

34.protected

访问控制的一种。
受保护的方法和变量只能给子类和基类访问。

protected int a = 1;
protected void b(){
    ...
}

35.public

访问控制的一种。
公有的方法、类、变量、接口能够被任何其他类访问。

36.return

方法中返回数据，并结束方法。

37.strictfp

使用strictfp关键字来声明一个类、接口或者方法时，那么该类、接口或者方法会遵循IEEE-754标准来执行，提高浮点运算的精度，并且减少不同硬件平台之间由于浮点运算带来的差异。

public strictfp double aDouble(){
    return 0d;
}

38.short

short是Java的基本类型之一（默认值0）,表示16位、有符号的整数。

范围：[-215,215)

short a = 0;

39.static

static修饰的语句块存放在堆的方法区中。

1. 静态变量：依附在类中的变量，可以被类的所有的实例共用。

static int a = 0;

1. 静态方法：依附在类中的方法。静态方法只能访问类中的静态变量和静态方法。

publlic static void b(){
    ...
}

1. 静态块：在类加载的时候执行块中的语句，块中不能访问非静态变量。

static{
    ...
}

1. 静态内部类：用static修饰内部类。

40.super

super即超类

1. 引用父类的的成员：

super.xxx

1. 变量或方法重名时用super调用父类的成员或方法。
2. 调用父类的构造方法:

super(xxx);

41.switch

switch用于分支结构，判断某个变量与一系列值是否相等。switch 语句中的变量类型可以是： byte、short、int 、char、String、enum。

switch(变量){
	case value1:语句1;
		break;
	case value2:语句2;
		break;
	...
	default:语句;
}

1. 若变量和case后的值相等则执行语句。
2. 当语句执行到break时跳到switch块后，如果没有break会产生穿透现象。
3. default分支必须为最后一个分支，在没有值和case变量相等时执行该语句。

42.synchronized

synchronized关键字用于保证线程安全。由这个关键字修饰的方法或者代码块保证了同一时刻只有一个线程执行该代码。

synchronized(obj){...}

当一个线程访问同步代码块时，检查obj是否有锁，如果有就挂起。如果没有就获得这个obj的锁，也就是把其他线程锁在了外面。当代码执行完毕时释放该锁，其他线程获得锁继续执行代码。

43.this

1. 指向当前对象：this.xxx
2. 形参和成员名字重名时时用this区分。
3. 引用构造函数。

44.throw

用于抛出一个异常。

throw (Exception);

45.throws   

在方法中将发生的异常抛出。

[控制访问](返回类型)(方法名)([参数列表])[throws(异常类)]{...}

46.transient

类接上序列化接口后，可以通过transient关键字将某些变量变得无法序列化。

transient int a = 1;

47.try

在try/catch中，将可能出现异常的语句放在try{}块中，出现异常之后代码将会终止并跳到catch中继续执行。

try{
    ...
}catch(Exception e){
    ...
}finally{
    ...
}

48.void

修饰方法，表示方法没有返回值。

49.volatile

volatile关键字修饰的变量在多线程中保持同步。相比synchronized效率要高，不会阻塞线程。但只能保证数据的可见性，不能保证数据的原子性。例如在处理i++的时候另外一个线程修改i的值，那么i的值将会发生错误，这是原子性导致的。

volatile int a;

50.while

while用于两种循环结构：

while(判读语句){
    循环体...
}

do{
	循环体...
}while(判读语句)

3.java标识符

注意事项:
1)起名字,可以数字,但是不能以数字开头
2)Java严格区分大小写,一定要起名字见名知意
3)标识符不能是Java中的关键字

3.1标识符:(起名字,"见名知意")

        对包名,类名,接口名,变量名,方法名,常量名起名字的一个字符序列!

3.2组成规则

        1)有0-9到数字组成
        2)字母字符(26个字母)
        3)$符号
        4)_下划线

3.3对包名(目录结构package) 起名字规范

        单级包:(字母都是小写) com包名
                                                xx.java
        多级包:包名和包名使用.隔开
                                                com.qf
        com下面会有一个qf文件夹
                                                xx.java文件

3.4对类名和接口名起名字是同样的:(遵循阿里规范:大驼峰命名法)

        定义类的时候:如果类名是单个单词,首字母大写,其余小写
举例
class Hello{}
class Demo{}
        如果类名它是多个单词组成,每个单词首字母大写,其余小写
举例:
class HelloWorld{}
class MakeNameDemo{}
class StartGame{}

3.5对变量名和方法名起名字是相同 的 (遵循小驼峰命名法)

        如果变量名是一个单词,那么 单词的字母全部小写
举例: 定义价格  int price = 5;
        如果变量名是多个单词,那么第一个单词字母小写,从第二个单词开始,每个单词首字母大写 ,其余小写!
举例: 定义苹果价格  int applePrice = 7;

3.6对常量起名字

        如果常量名,单个单词 ,字母全部大写  

举例 :HELLO

        如果是多个单词,字母全部大写,单词和单词之间用下划线隔开!

例如:jdk提供的Thread类 :线程
        定义线程优先级三个常量:只看格式 (最小优先级,默认优先级,最大优先级)
        public ?nal static int MIN_PRIORITY = 1;
        public ?nal static int NORM_PRIORITY = 5;
        public ?nal static int MAX_PRIORITY = 10;

三.java中的常量与变量

1.常量(常量在程序过程中,其值不发生改变的量!)

1.1字面值常量

        1)字符串常量:使用英文的符号"" 双引号括起来的任何内容都是字符串
举例:   "helloworld"

        2)字符常量:使用英文的'' 单引号阔括起来的单个字符内容
举例:   'a' :字符小a

当字符参与运算的时候的:ANSI码表里面对应的值

        'a' --- 97
        'A' --- 65        (熟记)
        '0' --- 48

        3)整数常量   100,97

        4)小数常量 3.1415926

        5)布尔常量: true/false

        6)空常量: 一般不能直接输出null,在引用数据类型(后面讲数组的说),默认值是null

        7)自定义常量 :跟一个关键字 ?nal(面向对象去讲!状态修饰符)

1.2进制也属于常量

任意进制到十进制的转换:  位权展开法

系数*基数的权次幂相加的结果

十进制 12345 ----十进制

=1*10^4 + 2 *10^3 + 3 *10^2 + 4*10^1+5*10^0

十进制到任意进制的转换:除基取余,除到商为0为止,余数反转!

                      商             余数

12345 /10 = 1234            5

1234/10 =     123             4

123/10 =        12              3

12/10 =           1               2

1/10 =             0               1

2.变量(在程序的执行过程中,其值不发生改变的量!)

2.1变量三要素

        变量名, 数据类型 初始化值

2.2变量的数据类型划分

       1) 基本数据类型: 四类八种

整数类型:默认int类型 byte (范围:-128~127) short int long

浮点类型:默认double   float(单精度) double(双精度,小数点更精确)

字符类型:char类型 一个中文对应两个字节(gbk编码格式)

布尔类型:boolean,'不参与运算,它在开发中,体现这种逻辑判断去用的

       2)引用数据类型: 面向对象部分讲解 ,数组,类,接口

2.3变量中隐式类型转换

例如

//变量计算的时候,byte,short,char三者之间不转换,参与运算优先提升int(考点)--->long--->float--->double

int a=1;
byte b=2;
int c=a+b;//可以接收,b这个变量在进行操作的时候,先提升为int类型,然后和a进行求和!

2.4变量的显示转换(强制类型转换,-->强转)

//显示转换:强转类型转换:就是将大的数据类型---转换成小的数据格式

//目标数据类型 变量名 = (目标数据类型)初始化值;

例如:

        int a = 4 ;

        byte b = 3 ;

        byte result = (byte)(a+b) ;

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

四.Java中的运算符

1.算数运算符(扩展++;--)

扩展的算术运算符
++或者--
        1)场景--->统计场景(统计用户的登录次数,猜数字游戏,统计用户多少次猜中了)
        2)流程控制语句循环结构语句中---++或者--
使用方式
        1)不参与运算,单独使用
                a)在数据的前面
                b)在数据的后面
结论:  无论++或者--在数据的前面还是后面,都是对当前数据进行自增1或者自减1
        2)参与运算
                a)在数据的前面
结论:
++或者--在数据的前面,先进行增1或者自减1,然后参与运算!
                b)在数据的后面
++或者--在数据的后面,先运算,然后进行自增1或者自减1 !

2.赋值运算符

面试题:
        short s = 1 ;
                1)s = s + 1 ;
                2)s +=1;
这个1),2)两段代码,哪一个会编译失败,哪一个成功,为什么?
        1)这个代码会编译报错,因为存在Java隐式类型转换byte,shor char 三者不转换,一旦参与运算,优先提升为int,所以s = s + 1 ;s先提升int和1相加,结果是int类型,而s类型short,无法接收int类型结果
        2)s +=1 ; 会成功,因为扩展赋值运算符+=,-=,*=,/=,%=,有一个特点:隐藏了强转类型转换
s +=1 此时等价于s = (short)(s+1) ;

3.逻辑运算符

面试题:
        逻辑双与&&和逻辑单与&有什么区别?
共同点:
        无论是逻辑单与&还是逻辑双与&&都是表达并列关系,而且都是有fasle则false!
不同点:
        逻辑单与&,对多个并列条件在执行的时候,效率比较低,因为都需要将这个符号左边的表达式和右边的表达式都需要执行一遍!
逻辑双与&& ,
        连接的表达式如果左边为false,则右边不执行(具有短路效果)开发中扩展的逻辑运算符,代替基本的运算符,执行效率高!

例子

/*
扩展的逻辑运算符
    逻辑双与&& 和逻辑双或||

逻辑双与&&:
    连接的表达式如果左边为false,则右边不执行(具有短路效果)
逻辑双或||:
    连接的表达式如果左边为true,则右边不执行(具有短路效果)

*/
class OperatorDemo2{
public static void main(String[] args){
//定义三个变量
int a = 3 ;
int b = 4 ;
int c = 5 ;
//逻辑双与&& 满足基本特点:有false,则false
System.out.println((a>b) && (a>c)) ;//false && false = false ;
System.out.println((a>b) && (a<c)) ;//false && true = false ;
System.out.println((a<b) && (a>c)) ;//true && false = false ;
System.out.println((a<b) && (a<c)) ;//true && true = true ;
System.out.println("-----------------------------------------------------") ;
//定义两个变量
int x  = 3 ;
int y  = 4 ;
System.out.println("x:"+x) ;
System.out.println("y:"+y) ;
System.out.println("-----------------------------------------------------") ;
//逻辑单与&
//System.out.println(((++x)==3) & ((--y)==4)) ;//false
//System.out.println("x:"+x) ;//4
//System.out.println("y:"+y) ;//3
//逻辑双与&&
System.out.println(((++x)==3) && ((--y)==4)) ;//false
System.out.println("x:"+x) ;
System.out.println("y:"+y) ;
}
}

4.三元运算符(三目运算符)

格式:
        (表达式)?执行true的结果:执行false的结果;
执行流程:
        表达式可以简单可以复杂,如果结果是true成立,则执行成立的结果否则不成立,则执行false的结果

例子

需求:
定义变量,求两个变量最大值(没有提示,都是int类型)
三个数据比较最大值?
*/
class OperatorDemo{
public static void main(String[] args){
//定义两个
int a = 10 ;
int b = 5 ;
//套用格式
//(表达式)?执行true的结果:执行false的结果;
//定义变量max
int max = (a>b)?a:b ;
System.out.println("两个数据中的最大值是:"+max) ;
System.out.println("---------------------------------------") ;
//定义三个变量
int x = 20 ;
int y = 50 ;
int z = 30 ;
//方式1:使用中间变量的方式 (推荐)
//使用中间变量的方式记录一下x和y的最大值
int temp = (x>y)? x:y;
//使用中间变量的结果和z进行比较
int max2 = (temp > z)? temp : z ;
System.out.println("三个数据中的最大值是:"+max2) ;
System.out.println("---------------------------------------") ;
//方式2:不建议(使用括号标记,格式好看,否则没有括号,不好看)三元运算符的嵌套
int max3 = (x>y)?((x>z)?x:z):((y>z)?y:z) ;
//int max3 = x>y?x>z?x:z:y>z?y:z ; //不带括号,阅读性很差
System.out.println("三个数据中的最大值是:"+max3) ;
}
}

 5.位运算符(了解即可)

位运算符号:-----哈希里面涉及到位运算符号
基本的位运算符号:
        位与&
        位或|
        位异或^(一个数据被另一个数据位异或两次,其值是它本身)
        反码~
        移位符号:
        << 左移   结论
        >> 右移 结论
        >>> 无符号右移

五.键盘录入(java.util.Scanner)

1.简介

让我们书写程序的时候,更加灵活----通过键盘录入数据
Scanner类就提供了很多功能(方法)--->快速键盘录入一些int类型,来进行运算或者写具体的逻辑!

2.操作流程

使用步骤:
        1)导包 :位置是在class的上面import java.util.Scanner ; //用谁导谁
        2)创建文本扫描器 ----java中的关键字 new 创建对象(具体在面向对象中讲)Scanenr 变量名(称为"键盘录入对象名") = new Scanner(System.in) ; 固定格式 变量名 ,自己起名字
        3)友情提示 "请输入一个数据:"
        4)通过文本扫描器录入数据 (整数默认int) 使用2)的变量名;

int 结果变量名= 变量名.nextInt() ; //.nextInt() :调用文本扫描器的提供功能,录入int类型
        5)使用这个结果变量名来进行操作

 例子

​

键盘录入两个数据,比较是否相等
键盘录入三个数据,比较三个数据最大值

*/
//1)导包

import java.util.Scanner ;
class ScannerDemo{
public static void main(String[] args){

//2)创建文本扫描器(创建Scanner类对象) 固定写法,变量名自己起
Scanner sc = new Scanner(System.in) ;

//3)友情提示
System.out.println("请您输入一个数据(int):") ;

//4)录入int类型数据
int result = sc.nextInt() ;  //.nextInt() :调用文本扫描器的提供功能 (固定写法)

//5)输出或者使用
//使用这个结果变量完成其他逻辑操作
System.out.println("录入的数据是:"+result);
}
}

[点击并拖拽以移动]
​

六.流程控制语句

1.顺序结构

        比较简单,所有程序都是通过jvm调用main进行的(入口)代码右上而下依次加载,除非在加载后面代码之前,jvm退出了!

顺序结构
class rDemo1{
public static void main(String[] args){
//代码由上而下依次加载
System.out.println("程序开始了...") ;
System.out.println("helloworld") ;
System.out.println("程序结束了....") ;
//jdk提供了System类有一个功能,exit(0),参数为0,正常终止jvm
System.exit(0) ;//固定格式先记住:可以终止jvm
System.out.println("over") ;
}
}

2.选择结构

2.java能干什么

2.1 if

执行流程：1.先判断关系表达式；

                  2.如果关系表达式符合要求，那么就执行语句体；

                  3.  如果不符合要求，那么不执行语句体；

                  4.  执行后面的其他代码

2.2if....else

执行流程：1.先判断关系表达式；

                  2.如果关系表达式符合要求，那么就执行语句体1；

                  3.  如果不符合要求，那么执行语句体2；

                  4.然后再继续执行其他代码；

2.3if.....else if.....else..........

执行流程：1.先判断关系表达式1；

                  2.如果关系表达式1符合要求，那么就执行语句体1；

                  3.如果不符合要求，那么继续判断关系表达式2是否符合要求

                        如果符合要求，执行语句体2；

                  4.如果关系表达式1，2都不符合要求，那么执行和关系表达式3；

                  5.然后继续执行；

/*
if语句格式3
格式3:
if(表达式1){
语句1;
}else if(表达式2){
语句2;
...
...
...
}else{
语句n;
}
场景:针对多情况进行判断
 执行流程:
首先,判断表达式1是否成立,成立,则执行语句1;
否则,不成立,继续判断表达式2是否成立,成立,执行语句2;
否则,不错成立...依次判断
....
....
如果上面都没有匹配的结果, 执行else中的语句n;
没有提示数据类型,都是int
需求
键盘录入学生成绩(满分100分),判断该学生成绩的等级的划分
90-100      "优秀"
80-90 "较优"
70-80 "良好"
60-70 "及格"
60以下 "不及格"
*/
//导包
import java.util.Scanner;
class IfDemo3{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入的学生的成绩: ") ;
int socre = sc.nextInt() ;
/*
if(表达式1){
语句1;
}else if(表达式2){
语句2;
...
...
...
}else{
语句n;
}
*/
/*
if(socre>=90 && socre<=100){
System.out.println("优秀") ;
}else if(socre>=80 && socre<90){
System.out.println("较优") ;
}else if(socre>=70 && socre<80){
System.out.println("良好") ;
}else if(socre>=60 && socre<70){
System.out.println("及格") ;
}else{
System.out.println("不及格") ;
}
*/
//测试程序:
//测试正确数据:正常范围内的数据
//测试边界数据:边界数据的是否在我们指定范围内
//测试错误数据:超了范围,不满足,应该也要包含进去
if(socre<0 || socre>100){
System.out.println("您输入的数据有误!") ;
}else if(socre>=90 && socre<=100){
System.out.println("优秀") ;
}else if(socre>=80 && socre<90){
System.out.println("较优") ;
}else if(socre>=70 && socre<80){
System.out.println("良好") ;
}else if(socre>=60 && socre<70){
System.out.println("及格") ;
}else{
System.out.println("不及格") ;
}
}
}

目录

一.java的概况(初识java)

1.什么是Java

3.java语言平台版本

4.Java语言特点

5.java开发环境搭建

5.1JVM

5.2JRE

5.3JDK

5.4JAVA_HOME环境变量的配置

6.main方法

7.添加注释(为了提高代码阅读性)

7.1单行注释

7.2多行注释

7.3文档注释

二.java的基本语法

1.java中的基本语法格式

2.java中的关键字(被Java语言赋予特定含义的单词,叫关键字!)

1.abstract

2.assert

3.boolean

4.break

5.byte

6.case

7.catch

8.char

9.class

10.const

11.continue

12.default

13. do

14.double

15.else

16.enum

17.extends

18.final

19.finally

20.float

21.for

22.goto

23.if

24.implements

25.import

26.instanceof

27.int

28.interface

29.long

30.native

31.new

32.package

33.private

34.protected

35.public

36.return

37.strictfp

38.short

39.static

40.super

41.switch

42.synchronized

43.this

44.throw

45.throws   

46.transient

47.try

48.void

49.volatile

50.while

3.java标识符

注意事项:1)起名字,可以数字,但是不能以数字开头2)Java严格区分大小写,一定要起名字见名知意3)标识符不能是Java中的关键字

3.1标识符:(起名字,"见名知意")

3.2组成规则

3.3对包名(目录结构package) 起名字规范

3.4对类名和接口名起名字是同样的:(遵循阿里规范:大驼峰命名法)

3.5对变量名和方法名起名字是相同 的 (遵循小驼峰命名法)

3.6对常量起名字

三.java中的常量与变量

1.常量(常量在程序过程中,其值不发生改变的量!)

1.1字面值常量

1.2进制也属于常量

2.变量(在程序的执行过程中,其值不发生改变的量!)

2.1变量三要素

2.2变量的数据类型划分

2.3变量中隐式类型转换

2.4变量的显示转换(强制类型转换,-->强转)

四.Java中的运算符

1.算数运算符(扩展++;--)

2.赋值运算符

3.逻辑运算符

4.三元运算符(三目运算符)

 5.位运算符(了解即可)

五.键盘录入(java.util.Scanner)

1.简介

2.操作流程

六.流程控制语句

1.顺序结构

2.选择结构

2.1 if

2.2if....else