码迷,mamicode.com
首页 > 编程语言 > 详细

北京尚学堂JAVASE课程

时间:2018-08-18 17:46:36      阅读:141      评论:0      收藏:0      [点我收藏+]

标签:ati   方式   回车符   sci   java se   幼儿园   10个   进制   分割   

北京尚学堂JAVASE课程

一、java历史-特点

1.计算机语言发展史

何为要发明计算机:为了进行科学计算,复杂的科学计算。
人类如何和计算机沟通,去分配任务。 通过计算机语言 实现 人类和计算机的交流。

计算机语言的发展史:
    大概的经历了三个阶段
    1:机器语言:计算机可以直接识别的语言。
        计算机可以直接识别的语言是二进制的语言。
        任何的计算机系统都有自己的指令的集合。计算机只能识别自己的指令集合中的二进制指令形式。
        0101

    1 + 1
    +:1010
    1010 0001 0001
    优点:运行的效率快。
    缺点:可读性很差,编写程序的门槛很高。

    
    2:汇编语言:指令集中每一个指令都使用了一个 字符序列来代替。
    1 + 1
    ADD 0001 0001   糖语法
    优点:代码可读性增强了,指令也更容易记忆了。
    缺点:多了一个编译的过程。


    3:高级语言: c  c++  java  c#
    1 + 1
    优点:开发的效率高了,可读性好了。学习的门槛降低了。
    缺点:需要将更高级的语法转换为 机器语言的形式。(编译 or  解释)。影响了最终的效率。

2.java历史和版本

1991年,Sun公司的Green项目,Oak
1995年,推出Java测试版
1996年,JDK1.0
1997年,JDK1.1
1998年,JDK1.2,大大改进了早期版本的缺陷,是一个革命性的版本,更名为Java2
1999 Java被分成J2SE、J2EE 和J2ME,JSP/Servlet技术诞生

J2SE:java 2 standard edtion。针对客户端,桌面程序开发的。标准版。
J2EE:java 2 Enterprise edtion  针对服务器端开发的。企业版。
J2ME:java 2 micro edtion 针对手持设备开发的。微型版。

2004年,J2SE 5.0 (1.5.0)  Tiger老虎.为了表示这个版本的重要性,J2SE1.5更名为J2SE5.0。 
2006年,J2SE 6.0 (1.6.0)  Mustang野马.此时,Java的各种版本被更名,取消其中的数字"2":J2EE更名为Java EE, J2SE更名为Java SE,J2ME更名为Java ME 
2009年4月20日甲骨文收购Sun公司,交易价格达74亿美元
2011年,JavaSE7.0 
2014年,JavaSE8.0

 

3.java特点

了解
特点:

Java是简单的:
不再有#include 和#define 等预处理功能
不再有struct,union及typedef
不再有函数、
不再有指针、不再有多重继承
不再有goto      
不再有操作符重载(Operatior Overloading)
不再有全局变量           取消自动类型转换,要求强制转换
不再有手动内存管理

Java是安全的:取消了指针,自动内存回收。


Java是完全面向对象的:继承、封装、多态


Java是健壮的:Java的强制类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证


java 最大的特点和优势。
java 的跨平台。

 

4.java跨平台原理

技术分享图片

1) C/C++语言都直接编译成针对特定平台机器码。如果要跨平台,需要使用相应的编译器重新编译。

2) Java源程序(.java)要先编译成与平台无关的字节码文件(.class),然后字节码文件再解释成机器码运行。解释是通过Java虚拟机来执行的。

3) 字节码文件不面向任何具体平台,只面向虚拟机。

4) Java虚拟机是可运行Java字节码文件的虚拟计算机。不同平台的虚拟机是不同的,但它们都提供了相同的接口。

5) Java语言具有一次编译,到处运行的特点。就是说编译后的.class可以跨平台运行,前提是该平台具有相应的Java虚拟机。但是性能比C/C++要低。

6) Java的跨平台原理决定了其性能没有C/C++

5.jvm 的作用简介

jvm:java virtual machine。

作用:
1:jvm 负责管理内存。分配内存,回收内存。
2:程序代码的加载。
3:解释字节码到机器码给cpu去执行。

 6.jdk

jdk: java development toolkit
java 开发工具包。

需要的开发的主要的工具:编写代码的环境(记事本)、编译的环境(编译器)、解释执行的环境(解释器)。

jdk 安装好之后,编译的环境,还有运行的环境 jvm 都安装完毕。


jre:java runtime environment。java 运行环境。


jdk 目录:
bin: binary javac.exe 编译工具 java.exe 解释器


安装jdk的要求:
安装 jdk1.8 版本。
不要安装多个 jdk 版本。
最好默认安装。

7.dos

1:编写源代码 注意保存。 ctrl+s
2: 使用编译器 javac.exe 编译源代码。
要借住 cmd 窗口。来使用编译器 编译源代码。


dos: disk operating system 磁盘操作系统。

在 windows 系统下 的 cmd.exe 可执行文件,是使用软件模拟的 dos 操作系统。

dos:是一个靠命令行来完成所有的操作的系统。


如何在windows 平台上 运行 dos 界面程序
cmd:command
1: 在开始菜单搜索处输入cmd 回车即可。
2:按windows键+R键 弹出 运行界面,输入cmd 回车。

内部指令:属于cmd 程序的内部的指令,内置指令。随着cmd 的启动就可以直接使用了。
外部指令:通常对应着磁盘上的一个可执行的文件。

要通过cmd 窗口 运行使用 javac.exe ???


认识 dos 操作系统的一些常用的指令

可以通过 指令 /? 了解当前指令的用法
例如:cd /? 回车

1:切换目录的指令
cd (change dirctory).
chdir

cd \ 回到当前目录的根目录。


2:切换盘符:盘符:回车

.. :代表当前目录的上一级目录
. :代表当前目录

3:dir (dirctory):显示当前目录下的所有的文件和目录的。

4:cls 清屏 clear screen

5:start: 开启另外一个dos窗口

6 : exit 退出当前dos窗口

了解
7:md | mkdir 创建目录

8:rd /s /q 目录

9:del 删除文件
del 删除所有文件 del *.* :
* 通配符 代表任意个字符
?:代表一个字符

10:copy 复制文件 copy 源文件路径 目的路径
copy c:\class\a.java d:\class\b.java

11 : move 剪切。

12 : ren 重命名 ren 源文件名字 新文件名字


快捷键:
TAB:自动补齐
上下箭头:快速使用之前使用过的命令。

8.第一个java程序

通过 dos 窗口 编译源代码。

javac  HelloWorld.java
回车:首先会在当前目录下找javac.exe ,如果当前目录下没有,会去环境变量 配置的path 的一个目录集合中去挨个查找。

配置环境变量 path。将 javac.exe 所在的目录添加到 path 中去。


配置环境变量的作用:
建议只配置path。
为了在 cmd 窗口中可以直接使用 javac 和 java 外部命令。

public class HelloWorld{
    public static void main(String[] args){
        System.out.println("Hello World!");
    }
}

public:java 的权限修饰符。
class:java的关键字
HelloWorld:类的名字,首字符大写。
public static void main(String[] args):入口方法,main 方法。格式是固定的。程序开始执行的地方。
将需要执行的代码 写到 main 方法中。
System.out.println("Hello World!");
将双引号中的内容(字符串)原样输出到cmd 窗口。还输出了一个换行符。



如何配置环境变量:
我的电脑-->右键属性-->高级系统设置-->环境变量--->在path 的末尾 添加 javac 编译程序所在的 目录的 bin目录。使用 半角分号 分割不同的目录。

如何编译和运行java 程序。
在 cmd 窗口中。首先要切换到 源代码所在的目录(使用英文目录)。然后使用 在命令行输入 javac HelloWorld.java 回车。
会生成一个.class 文件。  如果编译不成功。需要修改源代码。切记保存。重新编译。javac HelloWorld.java 回车。
然后,解释执行 class   命令行:java HelloWorld  回车。

public class Introduce{
    public static void main(String[] args){
        System.out.println("我是小杨老师!~");
        System.out.println("我是沧州人士!自幼习武!中途放弃!");
        System.out.println("欢迎大家来到北京尚学堂学习!");
        System.out.println("希望大家在接下来的时间里,好好学习,天天向上!不搞对象!");
        System.out.println("将来毕业找一个满意的工作,实现人生的理想!然后迎娶白富美,走向人生的巅峰!");
    }
}

 9.修改cmd 启动默认路径

windows 键+ R
输入:regedit 回车。
HKEY_CURRENT_USER--->Software--->microsoft--->Command Processor
autorun-->cd /d 目录

 二、计算机其他知识

1.进制

public class SystemTest{
    public static void main(String[] args){
        System.out.println(10);//直接书写一个数字,那么默认为10进制。
        System.out.println(0b1010);//二进制 高位添加 0b jdk1.7开始支持二进制
        System.out.println(012);//八进制  高位添加0
        System.out.println(0xa);//十六进制 高位添加0x
    }
}


四种进制的特点:
十进制:逢十进一,每一位上出现的数值的取值范围[0-9]
二进制:逢二进一,每一位上出现的数值的取值范围[0-1]  计算机底层使用二进制表示所有的数据。
八进制:逢八进一,每一位上出现的数值的取值范围[0-7]
十六进制:逢十六进一,每一位上出现的数值的取值范围[0-15]  必须使用一个字符表示[10-15] [a-f][A-F]

二进制:
一位二进制位 有两种状态 0、1。称之为1 bit。
1bit 是计算机中最小的存储单元了。
8 bits-->1 byte
1024 bytes--->1 KB
1024 KB--->1 MB
1024 MB--->1 GB
1024 GB--->1 TB
1024 TB--->1 PB

计算机通常使用字节为单位来处理数据。

使用四种进制来表示 0-15
二进制        八进制        十进制        十六进制
000           0          0            0
001           1          1           1
010           2          2           2
011           3          3           3
100           4          4           4
101           5          5           5
110           6          6           6
111           7          7           7
1000          10         8           8
1001          11         9           9
1010          12         10           a
1011          13         11           b
1100          14         12           c
1101          15         13           d
1110          16         14           e
1111          17         15           f

10000         20         16           10
10001         21         17           11
10010         22         18           12

1个二进制位 能表示2种状态。
2个二进制位 能表示4种状态。
3个二进制位 能表示8种状态。
4个二进制位 能表示16种状态。
n个二进制位 能表示2的n次幂种状态。

2.机器码-原码-反码-补码

对于任何的一个整数,在计算机中的存储的具体的表示形式?
二进制的机器码的表示形式??


定义了三种码制来表示一个数据
不同的码制代表着不同的表示机器码的规则。

原码:
规则:最高位为符号位,最左边的一个二进制位 为 符号位 。0 代表是正数。1 代表负数。剩下的二进制位数为数值位。表示数值的大小。
10:00001010
-10:10001010

计算机不使用原码来最终的表示一个数据。
原因:
1: +0 -0 00000000 10000000 原码形式有+0 和 -0之分。
2:设计cpu的时候需要考虑符号位的设计,大大加重了设计cpu的难度。

反码:
规则:
正数:如果是一个正数,那么反码和原码一致。
负数:符号位不变,其余的数值位1-->0 0-->1
-10: 1000 1010--->1111 0101


补码:
规则:
正数:补码和原码一致。三码合一。
负数:先求原码,再求反码,然后再 加1.
-10: 1000 1010--->1111 0101--->1111 0110
-1: 1000 0001--->1111 1110---> 1111 1111


计算机广泛的采用补码的形式来表示数据:
原因:
1:没有 +0 和 -0 之分。
0000 0000
1000 0000-->1111 1111--> 1 0000 0000

2:计算机的cpu 在进行数据运算的时候,补码的符号位 并没有被看作符号位。符号位的运算的规则和普通的数值位的运算的规则一致。
简化了cpu的设计。


规则:补码的补码是原码。
对补码 取反 +1 就是该补码的原码形式。
-1:1111 1111 ---> 1000 0000 --->1000 0001

3.练习

需求:使用四种进制来表示10并打印输出,并把-1的二进制字符串形式打印
    //10使用四种进制来表示输出
public class SystemTest{//18
    public static void main(String[] args){
        System.out.println(10);//直接书写一个数字,那么默认为10进制。
        System.out.println(0b1010);//二进制 高位添加 0b jdk1.7开始支持二进制
        System.out.println(012);//八进制  高位添加0
        System.out.println(0xa);//十六进制 高位添加0x
        //将-10 的二进制的字符串的形式打印
        System.out.println(Integer.toBinaryString(-1));//1111111111111111111111110110
        System.out.println(Integer.toBinaryString(-10).length());//32
    }
}

 4.进制的转换

各种进制之间相互的转换:

各种进制到十进制的转换:
123 = 1*10^2 + 2 * 10^1 + 3 * 10^0 = 100 + 20 + 3
0b1010110 = 2^1 + 2^2 + 2^4 + 2^6 = 2 + 4 + 16 + 64 = 86
0765 = 5 + 6 * 8 + 7 * 64 = 5 + 48 + 448 = 501
0x1ad = 13 + 10*16 + 256 = 13+160+256 = 429

十进制到其他进制的转换
10-->2
除二取余法:

技术分享图片

 

2<--->8
三个二进制位对应一个八进制位
0b1100110--->0146
0561--->101110001

2<--->16
四个二进制位对应一个16进制位。
101110001-->171

 三、标识符-数据类型-变量

1.标识符

技术分享图片

a b 3a _3 public1。
age
name
studentScore
stuScore


标识符的命名规范的基本的规范:
1:见名知意。通过名字能体现对应的内存区域的数据的内容。
2:驼峰命名法。多个单词构成的标识符,单词的首字符大写。
3:避免使用单字符标识符。


目前位置接触过的java 关键字
public class static void

2.数据类型

 技术分享图片

java 程序中支持哪些数据类型。
java 是一种强类型语言。所有的数据:标识符以及 字面的常量数据都是有类型的。

数据的具体类型有2种指定的方式:
1:显式指定。
2:隐式指定。通常是针对字面值。由编译器默认指定。
整数的默认类型为 int。
浮点数的默认类型为 double
‘A‘ 字符类型
true false boolean
"afdf" 字符串


java 支持的数据类型:
分为2大类:基本数据类型、引用数据类型。

基本数据类型:java 内置类型、简单数据类型。
1:4个整数类型
字节型 byte 8bits 1个字节 取值范围[-128~127]
短整型 short 16bits 2个字节 取值范围[-2^15 ~ 2 ^15 -1]
整型 int 32bits 4个字节 取值范围[-2^31 ~ 2 ^31 -1]
长整型 long 64bits 8个字节 取值范围[-2^63 ~ 2 ^63 -1]
2:2个浮点数类型
单精度 float 32bits 4个字节 小数点后可以保留7位。 一共有8个有效数字。
双精度 double 64bits 8个字节 小数点后可以保留16位。 一共有17个有效数字。
3:1个字符类型
字符 char 16bits 2个字节 [0~65535]
4: 1个布尔类型
布尔 boolean ??? 只有两个值 true false。

引用数据类型:复合数据类型、复杂数据类型
3个引用数据类型:
类: class
接口:interface
数组:[]

类型的作用:
1:决定了占用内存空间的大小。
2:底层的存储的格式
3:决定了最终显式的形式。

 3.变量

变量:Variable。
概念:变量的本质是一块内存区域,该内存区域中的值可以被修改。

局部变量:在方法内部定义的变量,称为局部变量。

局部变量定义的语法:
变量类型 变量名 = 初始值;

变量类型:java支持的任意类型。
变量名:合法的标识符

定义变量可以分为2步进行:
    变量类型 变量名;---->变量的声明
    变量名 = 初始值;---->变量的赋初值

变量的定义=======变量的声明+赋初值

局部变量的特点:
    局部变量必须先定义后使用。
    局部变量的内存在栈中分配。



//定义一个标识符,名字为 age,并给age 标识符对应的内存存一个short类型的值。
public class SimpleTypeTest{//18
    public static void main(String[] args){
        //数据的类型  标识符名字 = 初始值。
        //向jvm 申请一块内存,名字为age ,内存中的数据的类型为 short。占用2个byte。
        short age = 19;
        System.out.println(age);
        //定义标识符 用来存储 高考的分数 int 、圆周率 double 、班级中是否有女生 boolean。将内存中的数据全部依次打印。
        int score = 555;
        double pi = 3.1415926;
        boolean isGirlInClass = true;
        System.out.println(score);
        System.out.println(pi);
        System.out.println(isGirlInClass);
        
        
        //
        int weight;
        weight = 68;
        System.out.println(weight);//获取变量的值
        //weight = 70;
        weight = weight + 2;
        System.out.println(weight);//获取变量的值
        
    }
}

4.变量的定义的各种语法

//变量的各种语法定义
public class VariableTest{//18
    public static void main(String[] args){
        int a1 = 10;
        int a2 = 20;
        
        int b1 = 10, b2 = 20, b3 = 10;
        
        int c1, c2, c3;
        c1 = 32;
        c2 = 45;
        c3 = 67;
        
        int d1, d2 = 34, d3;
    }
}

 5.局部变量的内存分析技术分享图片

6.常量

java 中的常量 分为两种。

1:字面常量。通过数值的字面就可以知道数值的大小。
    字面常量有默认类型,类型由 编译器 指定。
    整数的默认类型为 int。如果超过了int 的范围,需要在末尾添加 L or l 来告诉编译器 当long类型来处理。
    浮点数的默认类型为 double。如果一个浮点数常量需要当作 float 来对待,那么需要在末尾添加 F or f。
    true false,默认是 boolean
    "字符串"  ‘A‘ 字符

2:不可变的变量。使用 final 关键字 修饰。终态变量。
    在变量的类型前添加关键字 final 即可。
    特点:只能初始化一次。只有获得变量值的权利,没有修改变量值的权利。


//不可变的变量 final
public class FinalTest{//18
    public static void main(String[] args){
        final double PI = 3.14;
        System.out.println(PI);
        //pi = 4.0;
        
        final int MAX_AGE;
        MAX_AGE = 135;
    }
}

 7.作用域

作用域:变量可以被访问的范围。


局部代码块:在方法体的内部的一对大括号。
局部代码块中可以写任何的java 代码。

作用:将局部变量的作用域范围控制的更小。

局部变量的作用域范围:从定义的位置开始。到变量所在的大括号的结尾处。

8.字符类型-转义字符

char 类型:可以当作整数来对待。 无符号的短整型。没有负数.取值范围 [0-65535].


字符集:字符的集合。字符集合中的每一个字符都对应着一个唯一的整数。

ASCII:单字节字符集。只用到了一个字节的后7位。128个字符。
    ‘0‘--->48
    ‘A‘--->65
    ‘a‘--->97

ISO8859-1: 西欧使用的字符集,单字节字符集。256个字符。兼容了ASCII。

gb2312:双字节字符集。兼容了ASCII。主要收录了中文简体。

GBK:兼容了 gb2312.增加了繁体中文,还有各个少数民族的符号。

utf-8:三字节的字符集。兼容了 ASCII。

Unicode:万国码。java 使用的字符集。jvm 使用的。保证所有的国家的符号都能识别。


转义字符:
\t:水平制表符  对应着键盘上的Tab键。
    作用:\t占用的半角的个数为[1-8].从\t包括之前的输出的内容。总共占用的半角的位数必须是8的倍数。\t用来补齐8个半角位的倍数的。
\b: 退格符:     对应着键盘上的 Backspace 键。
\r: 回车符:    让光标回到当前行的行首,后续的输出从行首输出。
\n: 换行符:    让光标去下一行。
    Enter 键对应两个字符:\r\n  让光标去到下一行的行首。

\‘ :字符单引号。
\" :字符双引号。
\\ :字符反斜杠。




//char 类型
public class CharTest{//18

    public static void main(String[] args){
        char myChar = ‘A‘+32;//65
        char myChar2 = 48;//0
        char myChar3 = ‘\u0064‘;//转义序列
        
        System.out.println(myChar);
        System.out.println(myChar2);
        System.out.println(myChar3);
        
        int age = 19;
         //字符串可以和任意类型 使用 + 连接符 将字符串和 基本数据类型的数据做连接。然后整体输出
        System.out.println("我的年龄:\t" + age);
        
        System.out.println("1234\"56789");
        System.out.println("\t123456789");//8个
        System.out.println("1\t23456789");//7个
        System.out.println("1234567\t89");//1
        System.out.println("12345678\t9");//8个
        
        System.out.println("1234\r56\n789");
        
        System.out.println(‘\‘‘);
        System.out.println(‘\\‘);
        
    }
    
}

 9.练习-Scanner

//根据键盘输入,输入一个圆的半径,求圆的周长和面积。
//告诉编译器 Scanner 来自哪里
//java.lang 包是java 的核心包。核心包中所有的内容都是被默认导入的。
//* 代表通配符,代表所有。
import java.lang.*;// 这行代码写不写都会存在。
import java.util.Scanner;
public class ScannerTest{//18
    public static void main(String[] args){
        //使用jdk 已经定义好的类。扫描器类。
        //创建一个扫描器对象,扫描键盘输入   System.in 对应着我们的标准输入设备-->键盘
        //java.util.Scanner scanner = new java.util.Scanner(System.in);
        Scanner scanner = new Scanner(System.in);
        //提高用户体验  UE 
        System.out.println("请您输入圆的半径:");
        //使用扫描器对象去接收键盘输入的一个整数。并返回该接收到的整数。
        int radius = scanner.nextInt();//阻塞式方法。会导致程序的阻塞。解除阻塞之后,程序继续执行。
        
        // 半径、周长、面积、圆周率
        //定义变量
        //int radius = 7;
        final double PI = 3.14;
        double area;
        double length;
        
        //求圆的周长和面积
        length = 2 * PI * radius;
        area = PI * radius * radius;
        
        //最后打印输出结果
        System.out.println("半径是:"+radius + "\t的圆的周长 = "+length + "\t面积 = "+area);
    }
}

10.Scanner 功能介绍

Scanner scan = new Scanner(System.in);

//hello world
String str = scan.next();//只能获得一个单词的字符串。
String str = scan.nextLine();//得到一行文本。
double dou = scan.nextDouble();// 得到一个双精度的浮点数
float fl = scan.nextFloat();// 得到一个单精度的浮点数


字符串的定义和使用。
int age = 10;
String str = "123";

 11.注释

java 中的注释: comment。

注释的作用:可以帮助开发者更好的理解,记忆,阅读程序代码的。

注释部分的内容,不参与编译。

给程序添加合适的注释是作为一个程序员的基本修养。

java中支持的注释的类型:
    三种:
    1:单行注释:    //后面的内容都是注释的内容。
    用法:
        1:注释的内容单独占用一行,解释下面一行的内容。
        2:在一行代码的末尾。添加注释。短注释。一般注释的内容不超过10个字符。
        3:将一行代码注释掉,让代码失效的。

    2:多行注释:    /*注释的内容*/
        用法:多行、单行、一行的一部分。

    3:文档注释:    /**注释的内容*/
        帮助我们生成代码的阅读文档的。
        

12.float & double

1:floatdouble 很多时候不能精确的表示一个小数。
    3.3
0b0.1--->0.5
0b0.01--->0.25
0b0.001--->0.125

小数点后的第n位上的1 对应的十进制小数的值为 1/2^n

floatdouble 不是为了精确运算而设计的。
floatdouble 很多时候只是近似表示 某个小数。


0.3F
0.0101010100000001010101

0.0101010101

 

四、操作符、运算符

1.算术运算符

1:java 程序支持哪些运算符。可以使用哪些运算符对数据进行计算。

概念:
1:操作数:参与运算的数据 称为操作数。
2:表达式:运算符和操作数的整体 称为表达式。
    单独的一个操作数也可以看作一个最简单的表达式。  int age = 1+1;
3:返回值:操作数 或者是 表达式 参与 运算的结果。

注意:参与所有运算的数据,都是操作数 或者 表达式的 返回值 参与的。

4:一元运算符:只需要一个操作数的运算符。也叫做 单目运算符。
5:二元运算符:需要两个操作数的运算符。也叫做 双目运算符。
6:三元运算符:需要三个操作数的运算符。也叫做 三目运算符。


一:算术运算符:
+
-
*
/
%
++
--


//算术运算符
public class MathTest{
    public static void main(String[] args){
        int num0 = 10, num1 = 20;
        //+  既是一个一元运算符,也是一个二元运算符。
        System.out.println(+ num0);//一元运算符
        System.out.println(num0 + num1);//二元运算符
        //-  既是一个一元运算符,也是一个二元运算符。
        System.out.println(- num0);//一元运算符
        System.out.println(num0 - num1);//二元运算符
        //*  二元运算符  两个操作数的乘积  运算的规则和数学中一样一样的。
        System.out.println(num0 * num1);//二元运算符
        System.out.println(-num0 * num1);//二元运算符
        System.out.println(num0 * -num1);//二元运算符
        System.out.println(-num0 * -num1);//二元运算符
        // / 二元运算符     两个操作数相除。运算的规则和数学中一样一样的。
        //如果两个操作数都是整数,那么结果为相除的整数部分。没有四舍五入。
        System.out.println(num0 / num1);//二元运算符
        System.out.println(-num0 / num1);//二元运算符
        System.out.println(num0 / -num1);//二元运算符
        System.out.println(-num0 / -num1);//二元运算符
        // % 二元运算符。a%b  a除以b 得到的余数  结果的符号位和左边的操作数一致。
        System.out.println(5 % 2);//1
        System.out.println(-5 % 2);//-1
        System.out.println(5 % -2);//1
        System.out.println(-5 % -2);//-1
        // / 和 % 的应用。 123.
        int num = 689;
        int unit = num % 10;
        int decade = num / 10 % 10;
        decade = num %100 / 10;
        int hundred = num / 100;
        System.out.println(num + "\t的百位:" + hundred + "\t十位:" + decade + "\t个位:" + unit);
        
        //自增运算符 ++ :一元运算符  实现对变量自增一的操作。
        //两种模式:前缀模式  后缀模式。
        num = 0;
        num = num + 1;
        ++ num;
        num ++;
        System.out.println("num = "+num);
        //后缀模式:先返回后自增。num++ 表达式的返回值 是 num 自增之前的值。
        // num ++ 先计算了得到了返回值。自增之前的值。然后 num 做自增+1操作。然后将 num ++ 之前得到的返回值赋值给 age;
        int age = num ++;
        System.out.println("num = "+num + "\tage = "+age);
        num = 0;
        num = num ++;
        System.out.println(num ++ + num ++ + num ++);//3
        System.out.println("num = "+num);//3
        num = 0;
        //前缀模式:先自增 后返回   表达式的返回值是 自增之后的值。
        System.out.println(num++ + ++num + num ++ - ++num);//0
        
        //自减运算符: -- :一元运算符  实现对变量的自减一 的操作。
        //后缀模式:先返回 ,后自减。。前缀模式:先自减后返回。
        
    }
}

2.练习

求随机数[100-1000)
//获得随机数
public class RandomNumberTest{
    public static void main(String[] args){
        //得到区间[100-1000) 区间通常是 前闭后开的。前包含,后不包含。
        final int MIN = 100;
        final int MAX = 102;
        
        //Math.random() 同样有返回值。返回值是一个随机的double 值。[0.0~1.0)
        System.out.println(Math.random() * (MAX-MIN) + MIN);
        
        //int value = 0;
        //Math.random() * (MAX-MIN) + MIN  [100.0~ 1000.0)  去掉小数
        int value = (int)(Math.random() * (MAX-MIN) + MIN);
        
        System.out.println("value = "+value);
        
    }
}


//随机得到两个[10-20]的随机数,定义变量保存两个随机数。然后打印该随机数。
//实现交换两个变量的值。
public class ChangeValueTest{
    public static void main(String[] args){
        //定义区间
        final int MIN = 10, MAX = 21;
        
        int num1 = (int)(Math.random()*(MAX-MIN)+MIN);
        int num2 = (int)(Math.random()*(MAX-MIN)+MIN);
        
        System.out.println("num = "+num1 + "\tnum2 = "+num2);
        
        int temp = num1;
        num1 = num2;
        num2 = temp;
        
        System.out.println("num = "+num1 + "\tnum2 = "+num2);
        
        //使用异或来实现。根据异或的特点实现的。
        num1 = num1 ^ num2;
        num2 = num2 ^ num1;
        num1 = num1 ^ num2;
        System.out.println("num = "+num1 + "\tnum2 = "+num2);
        
    }
}

3.赋值运算符

赋值运算符:
=:二元运算符。
赋值 操作  永远是 最后执行。
实现的功能:将右边表达式的返回值 赋值 给 左边的变量(可以是终态变量)。

= 左边 :左值 left value
= 右边 :右值 right value

左值:必须是变量 或者是 终态变量。
右值:可以是:
    常量 : 1
    变量 : age
    常量表达式:1 + 1 + 4
    变量表达式: x + y
    常量、变量表达式:1 + x;


左值的类型 要和 右值表达式的返回值的类型 要兼容。


复合赋值运算符:
+=
-=
*=
/=
%=


复合赋值运算符特点:
1:生成的字节码文件要稍微小一点点。
2:隐含了一个强制类型转换,强制转换的类型为 左边变量的类型。



//复合赋值运算符练习
public class AssignmentTest{
    public static void main(String[] args){
        
        int value = 10;
        
        //value = value + 10;
        value += 10;
        
        //value = value - 10;
        value -= 10;
        
        //value = value * 10;
        value *= 10;
        
        //value = value /10;
        value /= 10;
        
        //value = value % 10;
        value %= 10;
        
        byte age = 127;
        //age += 1;
        age = age + 1;
        
        System.out.println("age = "+age);
        
    }
}

4.关系运算符

关系运算符:表达的是 操作数之间的关系是否成立的。
    成立,关系表达式返回值为  true ,否则为 false。

6个关系运算符:
> : 大于:二元运算符。左边的操作数是否大于右边的操作数。
< :小于:二元运算符。左边的操作数是否小于右边的操作数。
>=:大于等于:二元运算符。左边的操作数是否大于等于右边的操作数。
<=:小于等于:二元运算符。左边的操作数是否小于等于右边的操作数。
==:等于:二元运算符。左边的操作数是否等于右边的操作数。
!=:不等于:二元的。左边的操作数是否不等于右边的操作数。


>  <   >=  <= :只适用于 数值型 包括 char 类型的数据。

==  != 适用于 java支持的所有的数据类型。


//复合赋值运算符练习
public class RelationTest{
    public static void main(String[] args){
        
        int num0 = 0;
        int num1 = 0;
        System.out.println(num0 + 1 > num1);//true
        boolean bool = num0 < ++ num0;
        System.out.println(bool);//true
        
        System.out.println(num0 == num0 ++);//true
        num0= 0;
        System.out.println(++num0 != num0 ++);//false
        
        float f1 = 11111111111111f;
        float f2 = 11111111111110f;
        System.out.println(f1);//1.11111108E13
        System.out.println(f2);//1.11111108E13
        System.out.println(f1 == f2);//true
        
    }
}

5.逻辑运算符

逻辑运算符:参与逻辑运算的操作数必须是 boolean 类型的数据。逻辑表达式的 返回值 也是 boolean 类型。

//逻辑运算符练习
public class LogicTest{
    public static void main(String[] args){
        // &  逻辑与 :二元运算符。规则:有一个操作数是 false 那么结果就是false。两个都是true 的时候,结果才是 true。
        // 规律:有假 则 假 ,全真 则真。  表达的关系 是 并且的关系。
        System.out.println(true & true);//true
        System.out.println(true & false);//false
        System.out.println(false & true);//false
        System.out.println(false & false);//false
        System.out.println();
        // | 逻辑或:二元运算符。规则:有一个操作数是 true,那么结果就是 true,都是false 结果才是false。
        // 规律:有真则真,全假则假。 表达的是或者的关系。
        System.out.println(true | true);//true
        System.out.println(true | false);//true
        System.out.println(false | true);//true
        System.out.println(false | false);//false
        System.out.println();
        // ^ 逻辑异或  二元运算符  规则:两个操作数相异为 true 相同为false。
        System.out.println(true ^ true);//false
        System.out.println(true ^ false);//true
        System.out.println(false ^ true);//true
        System.out.println(false ^ false);//false
        System.out.println();
        // ! 逻辑非  逻辑取反  一元运算符。规则:true-->false  false--->true
        System.out.println(!true);//false
        System.out.println(!false);//true
        System.out.println();
        // && 短路与  条件与  
        System.out.println(true && true);//true
        System.out.println(true && false);//false
        System.out.println(false && true);//false
        System.out.println(false && false);//false
        System.out.println();
        // &  和 &&  的区别
        // &:进行逻辑与运算的所有的操作数,不管前面的操作数的返回值的结果是否是false,所有的操作数都会进行运算。然后进行逻辑运算。
        // &&: 进行 短路与运算的过程中,如果前面有操作数的返回值 是  false。
        // 那么后面的所有的操作数将不再计算,直接返回整个逻辑表达式的结果为false。
        // 短路与的效率往往高于逻辑与,所以建议使用短路与。
        int value = 0;
        System.out.println( (1>2) && (value ++ > 0));//false
        System.out.println("value = "+value);
        // | 和 || 的区别。
        // || 如果进行 短路或 运算,如果有一个操作数的结果为 true,那么后续的操作数将不再计算,而直接返回整个逻辑表达式的值 为  true.
    }
}

6.位运算符

位运算符:
直接对底层的二进制位操作,效率相对较高。
位运算的数据的类型:整数、char//位运算符练习
public class BitTest{
    public static void main(String[] args){
        // &  按位与:二元运算符。 规则:低位对齐,进行按位与。 对应的位 有0则0  全1则1.
        System.out.println(3 & 5);//1
        //作用:1:可以将某个整数的某些二进制位设置为0。
        //2:可以得到某一个数的制定区间的二进制表示的数据。
        
        // | 按位或: 二元运算符。 规则: 低位对齐,进行按位或。对应的位,有1则1,全0则0
        System.out.println(3 | 5);//7
        //作用:
        //1:如果两个操作数 对应的位 上没有全1 的,那么进行按位或 和 加的效果一致。
        System.out.println(3 | 4);//7
        System.out.println(1 | 2);//3
        System.out.println(8 | 16);//24
        System.out.println(4 | 8);//12
        System.out.println(3 | 12);//15
        //让你们找10个数。20个数。使用其中的任意几个数。然后做加法。不会和其他的组合的结果重复。
        //1,2,4,8,16,32,64,128,256,
        //2: 可以让指定的某些二进制位的值设置为1.
        
        //按位异或 ^ 二元运算符。。规则:对应的位上 相异为1,相同为0.
        //特点:一个数先后和同一个数据异或两次,结果是它自身。
        System.out.println(3 ^ 4 ^ 4);//3
        //简单的加密
        char c1 = ‘我‘;
        char c2 = ‘爱‘;
        char c3 = ‘你‘;
        
        int key = 6666;
        
        c1 ^= key;
        c2 ^= key;
        c3 ^= key;
        System.out.println("密文="+c1 + c2 + c3);
        
        c1 ^= key;
        c2 ^= key;
        c3 ^= key;
        System.out.println("明文="+c1 + c2 + c3);
        
        // ~ 按位取反  一元运算符。规则:所有的二进制位0--->1  1--->0
        System.out.println(~0);//-1
        
        //移位运算符。
        // >> :带符号右移  :低位被移走,高位空出来的补符号位,正数补0 负数补1.
        System.out.println(-1>>1);//-1
        System.out.println(35>>2);//17
        System.out.println(101>>1);//50
        System.out.println(89>>4);//5
        //应用:对于某个区间的整数,右移动n位,等价于 该数除以 2的n次幂
        
        // << 左移 :高位被移走,包括符号位。低位补0.
        System.out.println(1<<1);//2
        System.out.println(1<<2);//4
        System.out.println(1<<3);//8
        //应用:在某些区间 左移n位等价于 乘以2的n次幂。
        System.out.println(1<<31);//8
        
        // >>> 无符号右移:低位被移走,高位补0.
        //应用:为了得到一个随机的正整数。
        final int MAX = 102, MIN = 100;
        //创建产生随机数对象ran
        java.util.Random ran = new java.util.Random();
        int value = ran.nextInt();//得到一个随机的int 类型的数据。
        System.out.println("value = "+value);
        //得到了一个随机的正整数
        value >>>= 1;
        //value = value >>> 1;
         System.out.println("value = "+value);
        value = value %(MAX-MIN) + MIN;
        System.out.println("value = "+value);
        //一句代码实现得到随机数。
        value = (ran.nextInt() >>> 1)%(MAX-MIN) + MIN;
        System.out.println("value = "+value);
    }
}

 7.条件运算符

java 中唯一的三目运算符。 需要三个操作数。

语法: 表达式-1 ? 表达式-2 : 表达式-3

解释:
表达式-1:必须是一个 boolean 表达式。返回值是 boolean 值的表达式。
表达式-2、表达式-3:可以是java 支持的任意的表达式。两个表达式的返回值的类型 需要兼容。

执行过程:
    1:判断 表达式-1 的结果。如果 结果为 true,那么整个条件表达式 返回 执行 表达式-2 并返回 表达式-2 的结果。
    2:如果结果为false,那么跳过 表达式-2,执行表达式-3,并返回 表达式-3 的返回值。

 8.运算符的优先级

1:乘除取余 大于 加减。
2:一元运算符 大于 二元运算符 的优先级。
3:二元运算符的优先级高于三元运算符的优先级。
4:赋值运算符优先级最低。
5:配合小括号使用。

9.练习

// 1:得到两个随机数,一个使用Math获得,一个使用Random获得。全部打印。使用三目实现,将比较大的结果求出来。
// 2:得到一个随机数,如果奇数,打印 xxx 是奇数 如果是偶数 ,打印 xxx 是偶数
import java.util.Random;
public class ConditionTest{
    public static void main(String[] args){
        //定义区间
        final int MIN = 10, MAX = 111;
        
        int num1 = (int)(Math.random()*(MAX-MIN)+MIN);
        //创建获得随机数的对象
        Random ran = new Random();
        int num2 = (ran.nextInt()>>>1)%(MAX-MIN)+MIN;
        
        int num3 = (int)(Math.random()*(MAX-MIN)+MIN);
        
        System.out.println("num = "+num1 + "\tnum2 = "+num2+ "\tnum3 = "+num3);
        
        int max = num1 > num2 ? num1 : num2;
        max = max > num3 ? max : num3;
        
        //嵌套的三目
        int max1 = num1 > num2 ? (num1 > num3 ? num1 : num3) : (num2 > num3 ? num2 : num3);
        
        System.out.println("max = "+max);
        System.out.println("max1 = "+max1);
        
        //
        String str = max % 2 == 0 ? "偶数" : "奇数";
        //(max & 1) == 0 成立,说明 max 的二进制形式的最末位是0
        str = (max & 1) == 0 ? "偶数" : "奇数";
        System.out.println(max + "\t是"+str);
        
    }
}

五、基本数据类型转换

1.算术运算时的转换

类型转换:
    java 不支持 不同类型之间的运算。
    如果有不同类型之间的数据做运算的话,那么首先第一步做同类型转换。编译器来完成这种转换的。自动的完成的。
    转换的规则:

    1:如果参与运算的操作数的类型是如下的类型中的:byte  char short int ,所有的类型都自动转换为 int 然后再做运算。
        结果也是 int2:如果参与运算的操作数的类型是如下的类型中的:byte  char short int ,而且一定包含 long 类型。所有的类型都自动转换为 long类型。然后再做运算。
        结果也是 long3:如果参与运算的操作数的类型是如下的类型中的:byte  char short int long,而且一定包含 float类型。所有的类型都自动转换为 float类型。然后再做运算。
        结果也是 float4:如果参与运算的操作数的类型是如下的类型中的:byte  char short int long float,而且一定包含 double类型。所有的类型都自动转换为 double类型。然后再做运算。
        结果也是 double。


    上述的转换都是 编译器 来完成的。自动完成的。在编译期完成类型的转换,也就是将小类型的数据 当作大类型的数据来使用(如果需要)。

    注意:第一种 和 第二种 自动转换 是 绝对安全的。 三四种 有可能存在精度的损失。java 允许这么做。

 2.赋值时的转换

规则:
    小类型:表示的数值的范围比较小的。
    大类型:表示的数值的范围比较大的。

可以直接把一个小类型的数据 赋值 给一个 大类型的变量。

引用数据类型的转换:
老虎当动物用。 自动转换。

 

3.类型自动转换图

技术分享图片

4.强制类型转换

强制类型转换。

如果有将大类型的数据当作小类型的数据来使用的时候,就需要强制类型的转换。
大类型--强制-->小类型  不安全的。   

语法:
(强制转换为的类型)(被转换的数据);
int x = 2;
byte b1 = (byte)(x+1);
b1 = (byte)x;

强制转换的规则:


//强制类型转换
public class PowerChangeTypeTest{
    public static void main(String[] args){
        //整数之间的强制转换:
        //只保留 低n位的二进制,直接将多余的高位砍掉。不考虑符号位。只保留低位的数值位。
        int i1 = 254;
        System.out.println(Integer.toBinaryString(i1));
        
        byte b1 = (byte)(i1+1);
        System.out.println(b1);//-1
        
        //浮点数向整数的强制转换:
        //1:没有超过整数的范围,那么直接去掉小数点部分。
        //2:如果被转换的数据超过了整数的最大值,那么结果为最接近该浮点数的整数
        System.out.println((int)1.1);//1
        System.out.println((int)1.1E20);//2147483647
        
        //double 强制转换为 float
        //1 : 没有超过被强转的类型,那么小数部分直接被截断。
        //2 : 超过了被强转的类型。结果为 Infinity
        System.out.println((float)1.111111111111111111111111111111111111);//1.111112 
        System.out.println((float)1.1E100);//Infinity  无穷大

        b1 = 127;
        b1 ++;
        System.out.println(b1);//-128  可以认为隐含了一个强制类型转换,转换的类型为 b1的类型。
        
        //b1 = b1 + 1;
        b1 = 127;
        b1 += 1;//隐含了一个强制类型转换,强制转换的类型为 左边变量的类型。
        System.out.println(b1);//-128 
    }
} 

5.字符串连接时的转换

System.out.println(""+a+b+c);

同样,字符串连接的时候,也只能是 字符串和 字符串之间做连接。
字符串可以和其他的任何类型做连接:
底层使实现:其他所有的类型,都要被转换为字符串之后在做连接。

6.练习

//得到一个随机字符[A-Z]or[a-z] (大小写也要随机),并打印.
import java.util.Random;
public class RandomCharTest{
    public static void main(String[] args){
        final int MAX = ‘Z‘+1;
        final int MIN = ‘A‘;
        //得到随机的大写字符
        char ranChar = (char)(Math.random()*(MAX-MIN)+MIN);
        System.out.println("随机的大写字符:" + ranChar);
        
        Random random = new Random();
        //大小写的随机
        boolean isUpperCase = random.nextBoolean();
        
        ranChar = isUpperCase ? ranChar : (char)(ranChar + 32);
        
        System.out.println("得到的随机字符为:" + ranChar);
    }
}

六、分支选择

1.java流程控制

java 的代码的执行的路径的选择的种类。

1:顺序执行。
    从上到下依次执行
2:分支选择:
    根据条件来选择执行某些代码,跳过某些代码。
3:循环:
    反复的执行某些代码。

 

2.if

if 语句: 单分支 选择。

if 是java 的关键字。

if 语句 的 语法:
if(条件){
    //if 代码块
}
//

解释:
    条件:必须是一个 boolean 表达式。返回值为 boolean 值的表达式。
    if 代码块:一个使用{} 封闭的代码块。里面的内容可以是java 支持的任意行数的代码。


执行过程:
    1:首先计算条件 的返回值。如果是 返回值 为 true。那么执行 if 代码块中所有的内容。
    2:如果条件的返回值 为 false。那么就跳过所有的 if 代码块中的内容。

注意:
    1:如果if 代码块中的内容为一行 代码,那么大括号可以省略。建议添加大括号,即使是一条java 代码。
    2:不要在 条件小括号后 添加 分号。一个单独的分号是一条完整的java 语句。空语句。

 3.if-练习

//求两个随机数的最大值  范围[0-20].
//需求:产生一个随机数,范围[0-20]. 来代表一个年龄 age,
//使用if 语句,如果 age [0-3] 输出 还没有上学 [4-6] 幼儿园小朋友  [7-12] 小学生 [13-15] 中学生 [16-18]  高中生 [19-22] 大学生。
public class IfTest{
    public static void main(String[] args){
        final int MAX = 21, MIN = 0;
        //求两个随机数
        int num0 = (int)(Math.random()*(MAX-MIN)+MIN);
        int num1 = (int)(Math.random()*(MAX-MIN)+MIN);
        System.out.println("两个随机数为:"+num0 + "\t\t"+num1);
        int max = num1;
        if(num0 > num1){
            max = num0;
        }
        System.out.println("max = "+max);
        // if(num1 >= num0){
            // max = num1;
        // }
        //产生一个随机的年龄
        int age = (int)(Math.random()*(MAX-MIN)+MIN);
        System.out.println("age = "+age);
        if(age >=0 && age <=3){
            System.out.println("还没有上学!");
        }
        if(age >=4 && age <=6){
            System.out.println("幼儿园小朋友!");
        }
        if(age >=13 && age <=15){
            System.out.println("初中生!");
        }
        if(age >=7 && age <=12){
            System.out.println("小学生!");
        }
        if(age >=16 && age <=18){
            System.out.println("高中生!");
        }
        if(age >=19 && age <=22){
            System.out.println("大学生!!");
        }
    }
}

 

北京尚学堂JAVASE课程

标签:ati   方式   回车符   sci   java se   幼儿园   10个   进制   分割   

原文地址:https://www.cnblogs.com/961013-yu/p/9497353.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!