Java第二课，变量和数据类型

1 Java第二课

1.1 回顾:

1、 Java的发展历史，java的开发平台：JavaSE(标准版)、 JavaEE(企业版)、JavaME(微型版)

2、 Java语言的特点:面向对象 跨平台(字节码文件->在不同的平台[操作系统]上有不同的虚拟机JVM) 健壮性(强类型,没有指针，不用强制回收对象[GC]) 分布式 多线程 动态性等;

3、 JDK JRE JVM: 三者 关系，JDK的安装和配置环境变量; path:指向jdk安装目录下的bin目录; JAVA_HOME: 指向jdk的安装目录; classpath: 特别要注意, 要有一个 .; jdk下的lib目录 和 tools.jar ;

4、 javac 负责编译java源代码的; java 解释执行java的字节码文件. Javadoc生成文档。

Javap 查看字节码文件对应的源文件的信息[反编译]

5、 IDE工具MyEclipse/ Eclipse的安装配置（JRE）

6、 Java基本语法:

package day01;

public class Introduce{

public static void main(String[] args){

//\n 才是转义字符 表示换行 /n只是两个简单的字符 / n

//ln line 换行 printly() ?

System.out.println(“我叫某某某\n毕业于麻绳理工/n爱好是玩”);

}

}

7、 Java代码的执行过程： .java 编译 字节码文件.class java(JVM) 执行 ->结果

1.1.1 代码时间:

自我介绍,要求从类的定义开始，注意单词的大小写;

注意:

在main方法中的，每一行代码的结束记得要加 ;

1.2 课后作业讲解:

打印输出个人信息:

输出结果:

1.3 在Eclipse中，有一些快捷键

输入法为英文状态(美式键盘)

代码快速提示: alt+/ main/sysout

类重命名 : F2

单行的注释: Ctrl +/ 再按一次ctrl+/ 取消原来的注释

块注释: ctrl+shift+/

取消块注释: ctrl+shift+\

保存: 经常保存 ctrl+s

代码对齐: ctrl+shift + f

部分快捷键,具体…

1.4 Eclipse操作，导入工程:

基本操作: 右键->import->General->Existing Project into workspace->浏览->找到工程的文件夹->点击确定….

2分钟导入一个工程到你自己的Eclipse中.

1.5 Java中的关键字:

保留字: 例如 package ,class ,int void 等，这些符号是java中已经定义好，我们自己定义变量的时候，不能使用.

	关键字
类	enum、interface、class、extends、implements
对象	new、instanceof、this、super
包	package、import
数据类型	byte、short、int、long、float、double、char、boolean
分支	if、 else、switch、case、break、continue
循环	do、while、for
方法	void、return
异常	throw、throws、try、catch、finally
修饰符	Abstract、final、private、protected、public、、static、synchronized、strictfp、native、 assert、transient、volatile
保留字	const、goto

1.6 Java中的标识符，常量，变量:

小明有5块钱，小明和小红的钱加在一起共有12块，问，小红有几块钱?

解: 假设小红有x元钱:

5+x = 12;

标识符可以用来定义类，方法，变量等等，那么，这个标识符有哪些常见的规则：

1. 标识符应该由字母 数字 下划线和$符号组成.

2. 不能以数字开头

3. 要有一定含义,尽量遵循骆驼[驼峰]命名的方法，第一个单词小写，后面每个单词首字母大写 studentName/age.

4. 在同一个作用域中，不能重复。

5. 不能是保留字[关键字]:

常量的定义:

每个字母都大写;

Final String FLAG=”SUCCESS”;

1.7 变量和常量：

常量: 在程序运行期，这个值应该一直保持不变; 现实生活中的性别，常量不变的; 数学中: π：3.14.

//定义一个常量 表示一个人的性别 男/女

final char sex = '男';

//The final local variable sex cannot be assigned.

//It must be blank and not using a compound assignment

//常量一旦赋值 将不能再修改

sex = '女';

变量:通俗来说，就是和常量对应，程序运行期内是可以发生改变的，本质来讲，变量应该是在内存中一个存储区域; 这个存储区域是有大小的，大小是由数据类型来确定的.

public class Test02 {

public static void main(String[] args) {

// TODO Auto-generated method stub

// 数据类型 变量名 = 值 ;

int age = 12; //int 占四个字节

int a = 1;

// 同时声明多个变量，并赋值

int f = 1, g = 2, h = 3;

// 声明变量 而不直接赋值

int b=3;

// 同时声明多个变量

int c, d, e;

//输出变量的值

System.out.println(age);

//如果用+ 来连接 数字格式的变量

System.out.println(f+g+h);

System.out.println("f: "+f+",g: "+g+",h :"+h);

//那如果我们输出b c d e的值呢？

//The local variable b may not have been initialized 变量b没有初始化，就是没有赋值

System.out.println(b);

//可以修改age的值

age = 13;

System.out.println("age: "+age);

}

如何定义变量和常量:

数据类型 变量名 = 值; //将右侧的值 赋值给左侧的那个变量

1.8 常见的数据类型：

int :整数 4字节长度

float :单精度浮点型 4字节

double :双精度浮点型 8个字节

char : 字符 2字节

上图有个错误: int 类型的范围的最大值是 2147483647 ,注意：

1.9 ASCII码表:

 

public class Test5 {

public static void main(String[] args) {

// TODO Auto-generated method stub

int n = 1;

//红色波浪线上点击 F2

//Type mismatch: cannot convert from double to float

//类型 不匹配 ,不能 从double 转换为 float 进行类型转换

//在java中，默认写的小数字，都是double 类型 1.23是一个double

//方法1 在1.23后加一个f

float f = 1.23f;

//方法2 强制转换(显式) (float)

//可能会丢失精度

float f1 = (float) 1.2312121212121;

double d1 = 12.34;

//这里也包含一个类型的转换,自动转换(隐式),其实double中是包含了int类型的;

double d2 = 1; //不会出错,java语言强类型,变量是什么类型 (double),那么=赋值的那个值就是什么类型(1 int?)

}

}

1.10 类型转换:

Java代码中,数据都是强类型;

一旦定义了一个变量,这个变量是神马类型,那么他的值也必须是特定的类型:

Eg:

int n =值; //这个值必须是int类型,或者比int类型要小;

double d=值; //这个值必须是double 或者double小;

1.11 一个精度问题：

保留两位小数:

1.12 课堂练习:

1) 实现int+char+float+double类型的求和操作;

变量定义： 数据类型 变量名 = 值;

分析: 多个数据类型累加，最终的结果是什么类型? Double

 

package day02;

public class Test06 {

public static void main(String[] args) {

//定义四种类型的变量并赋值

int a = 1;

float f = 1.23f;

char ch = 'A';

double d = 12.3434343;

double sum = a + f + ch + d;

// 输出

System.out.println("sum :" + sum);

//输出结果要保留几位小数(很多种方法)

System.out.printf("%.2f",sum);

}

}

2) 实现int +float+double类型的求和操作,但是要求int ,float,double是从控制台输入进来的;

package day02;

import java.util.Scanner; //目的是导入Scanner类所在的位置

/**

* int +float+double

* @author Administrator

*

*/

public class TestScanner {

public static void main(String[] args) {

// TODO Auto-generated method stub

// Scanner cannot be resolved to a type

//无法识别Scanner这个类

Scanner sc = new Scanner(System.in);

System.out.println("请输入一个整数");

//等待用户从控制台输入一个整数

int i = sc.nextInt();

System.out.println("请输入一个单精度浮点型");

//等待用户从控制台输入一个整数

float f = sc.nextFloat();

System.out.println("请输入一个双精度浮点型");

//等待用户从控制台输入一个整数

double d = sc.nextDouble();

double sum = i + f + d ;

System.out.printf("累加结果: sum %.2f",sum);

//用完了记得要关闭close

sc.close();

}

}

小问题:

1.13 两段有意思的代码:

代码片段1：

代码片段2：[面试题]

package day02;

public class TestCode {

public static void main(String[] args) {

// TODO Auto-generated method stub

//short类型

short x = -32768;

//--x 表示的是在原来那个值得基础上,-1

//x = 10; --x;=>9

//-32768 -1 =>--32769

//因为我们short类型数据范围: -32768 - 32767

System.out.println(--x);

short y = 32767;

System.out.println(++y);

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

//尽量听懂

byte b = (byte)-129;

//-129 明显超出了byte类型的范围

//认为 -129 默认是int类型 4字节 /byte类型只有一个字节

//byte b =-129;

//byte b = 11111111 11111111 11111111 01111111;

byte b1 =(byte)-129; //01111111

System.out.println("b :"+b); //? 127

}

}

分析：

正数不考虑,因为正数：它的原码、反码、补码相同。

负数,二进制

原码->(除了符号位 ，取反)反码->(负 +1 )补码。

Java中是以补码来表示的;

Byte: 1字节 8位

Int(-129): 4个字节 32位

需要-129转换为二进制，然后取反，再补。 再丢高位，留8位;

129:转换为二进制(如果不会转换,请使用计算器) 除以2取余数

00000000 00000000 00000000 10000001

负数: 符号位(1表示的是负号)

10000000 00000000 00000000 10000001

取反(符号位不变，其他相反)

11111111 11111111 11111111 01111110

再补(+1) [java中存储的-129就是这样的]

11111111 11111111 11111111 01111111

丢(只保留后面8位,因为类型是byte类型了)

01111111

1.14 控制台输入:

控制台的输入:

Scanner

package test;

import java.util.Scanner;

public class TestScanner {

/**

* @param args

*/

public static void main(String[] args) {

// TODO Auto-generated method stub

// alt + /

System.out.println("请输入一个数字");

Scanner sc = new Scanner(System.in);

int i = sc.nextInt();

// 对i进行一些操作

System.out.println(i % 2 == 0 ? "偶数" : "奇数");

}

}

1.15 常见的运算符:

赋值运算符: = int a =1; 复合赋值运算符: +=, -= *= /= %=

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

比较(关系) : == != > < >= <= 返回值是一个boolean类型的 true /false ,用来判断

逻辑运算符: &&｜｜!

条件运算符: 表达式1?表达式2 :表达式3 ;

1.16 运算符的练习 :

1. 从控制台输入2个数字,将两个数字的和,差,积,商,余计算出来;

整数和浮点数的 /运算结果是不同;

2. 从控制台输入2个数字,得到两个数字中的最大值[int];

3. 从控制台输入3个数字,得到三个数字中的最大值[int];

1.17 简单的比较问题:

package day02;

public class TestOperator {

public static void main(String[] args) {

System.out.println("比较的两个整数");

int a = 1, b = 1;

System.out.println("a==b: " + (a == b)); // true

System.out.println("a!=b: " + (a != b)); // false

System.out.println("a>=b: " + (a == b));// true

System.out.println("a<=b: " + (a == b)); // true

System.out.println("比较的两个小数");

//观察以下代码，得到的结果是 true,因为数字值 1.0,其实本质上java代码处理的时候当成整数的,只要10进制的值,能转换为整数,就可以进行比较,但是如果不能得到一个整数(1的倍数),两个数字就不能比较

//二迚制

double d = 1.0d;

float f = 1.0f;

System.out.println("d == f: " + (d == f));// true

//因为赋的值为小数，1.05，因为数据类型不一样

double d1 = 1.05d;

float f1 = 1.05f;

System.out.println("d1 == f1: " + (d1 == f1));//false 

//得到一个结论，如果是小数格式的数据，进行比较的时候，不能用==去比较 ,但是可以用- 例如

System.out.println(d1-f1>0); //此时如果值 true,认为d1>f1

}

}

1.18 课堂练习:

从控制台输入两个数字，将这个两个数字交换后输出(要求不能定义第三个变量);

1. 可以使用第三个变量

2. 不能使用第三个变量

参考代码:

package day02;

import java.util.Scanner;

/**

* 交换两个变量的值

* 

* @author Administrator

*

*/

public class TestSwap {

public static void main(String[] args) {

// TODO Auto-generated method stub

// 0 创建Scanner对象

Scanner scanner = new Scanner(System.in);

// 1 获取用户从控制台输入的值

System.out.println("请输入整数1");

int n1 = scanner.nextInt();// 接收一个整数进来

System.out.println("请输入整数2");

int n2 = scanner.nextInt();// 接收一个整数进来

System.out.println("交换之前: n1: " + n1 + ", n2: " + n2);

// 2 交换

int t = n1;

n1 = n2;

n2 = t;

// 3交换完成后的输出

System.out.println("交换完成: n1: " + n1 + ", n2: " + n2);

// 4关闭scanner

scanner.close();

}

}

不定义第三个变量的核心代码:

//将n1+n2赋值给n1

n1 = n1 + n2; //1 2

//经过上面的代码之后 n1的值变成两个数字的和 ;但是n2还是n2 n1=>3 n2=2

n2 = n1 - n2; // n1=>3 n2=2 3-2 =1 经过这个代码的执行 n2=1 =>此时n1 =3

n1 = n1 - n2; //执行代码 n1 =>3 n2=>1 n1=2

异或的运算符实现:

“异或”的运算方法是一个二进制运算：

1^1=0

0^0=0

1^0=1

0^1=1

两者相等为0,不等为1.

这样我们发现交换两个整数的值时可以不用第三个参数。

如a=11,b=9.以下是二进制

a=a^b=1011^1001=0010;

b=b^a=1001^0010=1011;

a=a^b=0010^1011=1001;

这样一来a=9,b=13了。

//将n1^n2赋值给n1

n1 = n1 ^ n2; //1 2

n2 = n1 ^ n2; //

n1 = n1 ^ n2; //

1.19 运算符: ++ -- 在前和在后的区别:

package test;

public class TestClass2 {

/**

* @param args

*/

public static void main(String[] args) {

// TODO Auto-generated method stub

/* int i=1;

i++;

System.out.println("i :"+i);//2

++i;

System.out.println("i: "+i);//3

*/

int i=1;

//i++ 先引用i的值，然后再做自+

System.out.println("i :"+(i++));//1

//++i 先+ 再引用i的值

System.out.println("i: "+(++i));//3 

}

}

1.20 面试题:

如何用比较快速的方法得到2的4次方?

2<<3

2向左移位,3位.将2转换为2进制; 10 10000

00000010

00000100

00001000

10000=>2进制=>

1.21 Swtich-case结构:

中的变量类型，支持byte char short int 如果是jdk1.7(编译) 还可以支持String类型.

1.22 总结：

1、 变量,常量[final],声明，赋值，定义，命名规则等.

2、 数据类型(8个基本类型 byte .short.int.long.float.double.char.boolean) ,

3、 数据类型的转换(强制 自动转换)

4、 运算符(算术[++ --] 赋值 比较 条件运算符 ==)

5、 控制台的输入(Scanner)

1.23 作业:

1. 预习作业: 引用类型[String],其他的运算符[逻辑].条件结构(if switch等等)

2. 代码作业： 用户输入一个5位数(12345),将各个位数的数字取出来，求和输出: 1+2+3+4+5的结果 15

package day03.review;

import java.util.Scanner;

/**

* 2. 代码作业： 用户输入一个5位数(12345),将各个位数的数字取出来，求和输出: 1+2+3+4+5的结果 15

*

* @author Administrator

*

*/

public class Test_HomeWork01 {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

System.out.println("请输入一个5位整数");

// 取出来每个位上的数字 12345 =>%10 得到的是个位

// 取出来每个位上的数字 12345/10=>1234 =>%10 得到的是个位

int n = input.nextInt();

// 得到个位

int ge = n % 10;

得到10位

int shi = n / 10 % 10;//

// 得到百位

int bai = n / 100 % 10;

// 得到千位

int qian = n / 1000 % 10;

// 得到万位

int wan = n / 10000;

int sum = ge + shi + bai + qian + wan;

System.out.println(n+" 各个位上的数字和 ："+sum);

input.close();

}

}

提示:需要用到 %

3. 输入三位数，判断这个数字是否是水仙花数; 153: 1的立方+5的立方+3的立方 == 153

package day03.review;

import java.util.Scanner;

/**

* 2. 3. 输入三位数，判断这个数字是否是水仙花数; 153: 1的立方+5的立方+3的立方 == 153

*

* @author Administrator

*

*/

public class Test_HomeWork02 {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

System.out.println("请输入一个3位整数");

// 取出来每个位上的数字 153 =>%10 得到的是个位[3]

// 取出来每个位上的数字 153/10=>15 =>%10 得到的是十位[5]

int n = input.nextInt();

// 得到个位

int ge = n % 10;

// 得到10位

int shi = n / 10 % 10;//

// 得到百位

int bai = n / 100;

int sum = ge * ge * ge + shi * shi * shi + bai * bai * bai;

// 判断条件

char result = sum == n ? '是' : '否';

System.out.println(n +" "+ result + "水仙花数");

input.close();

}

}

1.24 附加题:

1.24.1 解法1:

数据130是int类型的十进制数据

首先需要将十进制的130转换成二进制数据

1 0 0 0 0 0 1 0

由于130是int类型,所以是占4个字节的，所以在内存的表现形式是

00000000 00000000 00000000 10000010

直接截取

1 0 0 0 0 0 1 0

通过观察最高位符号位是1,即符号位为1，这是一个负数，因为在计算机中所有的数据都是以补码的形式出现的所以要算它的补码;

原码：1 0000010 原码变反码，最高位符号位不变，其他数值位1变0,0变1得反码

反码：1 1111101 反码变补码就是反码加1得

补码；1 1111110

最终的看到的结果就是

1 1111110最高为是符号位不运算，数值为转化为十进制是64+32+16+8+4+2=126符号位负

所以为-126

1.24.2 解法2:

强制转换过程：

130作为int是四个字节

00000000 00000000 00000000 10000010

它是一个正整数，所以其原码，反码和补码都是相同的。

强转时截取其最后的一个字节 100000010

对于截取后的来说，截取的是int的补码，所以要转为原码显示

10000010是一个符号为1的负数

符号位 数值位

补码    1         00000010

反码    1         00000001

原码     1        11111110    =   （-）126

转载于:https://www.cnblogs.com/knowno/p/11208559.html