一丶运算的前提是数据类型必须一致(掌握)
(1) 观点一:(掌握)
// A: byte short char-int-long-float-double 默认大小转化时向最大的数据类型靠近, (除了 下面的观点的数据类型外)
// B: byte short char 在运算时默认转化成int 类型进行运算
// A: byte short char-int-long-float-double
// B: byte short char 在运算时默认转化成int 类型进行运算
@Test
public void test1()
{
byte b = 4;
int i = 3;
// int sum = b + i;
// byte sum = b + i;
short s = 2;
byte b1 = 1;
// (1) 验证成功, byte short char 在运算时默认转化成int 类型进行运算
// short sum = s + b1;
System.out.println("sum = " + sum);
}
(2) 面试题:(掌握)
/*
面试题：
byte b1=3,b2=4,b;
b=b1+b2;
b=3+4;
哪句是编译失败的呢？为什么呢？
b = b1 + b2;是有问题的。
因为变量相加，会首先看类型问题，最终把结果赋值的也会考虑类型问题。
常量相加，首先做加法，然后看结果是否在赋值的数据类型范围内，如果不是，才报错。
*/
class DataTypeDemo6 {
public static void main(String[] args) {
//定义了三个byte类型的变量，b1，b2，b3
//b1的值是3，b2的值是4，b没有值
byte b1 = 3,b2 = 4,b;
//b = b1 + b2; //这个是类型提升，所有有问题
b = 3 + 4; //常量，先把结果计算出来，然后看是否在byte的范围内，如果在就不报错。
}
}
注意:(掌握)
常量之间的运算结果是在编译成字节码文件时便被计算完毕, 成为一个新的常量例如: int a = 3 + 7 编译后便成为 int a = 10, 即使是 int a = 0; a = 3 + 7;, 在编译时也会变成 int a = 3 + 7; 这就是编译器的优化效果, 但是常量是存在数据类型, 从 c++ 方面便可简单的看出来 const int a = 10; 这个便是常量, 在java中也是存在常量 的 例如 : private final String str = "aaaa"还存在常量对象, private final String str1 = new String("aaa");还有 从 float 和 double 类型的常量可以看出来常量存在数据类型. 0.01f这些都是常量
(3)案例思考题:(掌握)
// 思考题5
// 'a' = 97
@Test
public void test6()
{
System.out.println('a');
// 这个将被虚拟机设置成 98
System.out.println('a' + 1);
// 这个在编译期间就被编译成 "helloa1"
System.out.println("hello" + 'a' + 1);
// "98hello"
System.out.println('a' + 1 + "hello");
// 5 + 5 = 55
System.out.println("5 + 5 = " + 5 + 5);
// 10= 5 + 5
System.out.println(5 + 5 + "= 5 + 5");
}
// 思考题4
// byte b = (byte)120; -127 ~ 126;
@Test
public void test5()
{
// byte b = -126;
byte b = (byte)130;
System.out.println(b);
}
// 思考题3:
// byte b1 = 3, b2 = 4, b;
// b = b1 + b2;
// b = 3 + 4;
@Test
public void test4()
{
byte b1 = 3, b2 = 4, b;
// b1 b2 在运行时, 类型提升了, 所以有问题
// b = b1 + b2;
// 常量, 先把结果计算出来, 然后看是否在 byte 的范围内,
// 如果不在就报错
b = 3 + 4;
System.out.println(b);
b = 10;
System.out.println(b);
}
// 思考题2:
// 下面这两种方法有没有区别??
// float f = (float)12.345;
// float f = 12.345f;
// 一个是强制转化, 一个是原先就是 float 类型
@Test
public void test3()
{
// 但是我在反编译之后发现 这下面两句都一样的处理方式
float f = (float)12.345;
float f1 = 12.345f;
}
// 思考题1:
// double d = 12.345;
// float f = d; ???
@Test
public void test2()
{
double d = 12.345;
float f = (float) d;
System.out.println(f);
}
// A: byte short char-int-long-float-double
// B: byte short char 在运算时默认转化成int 类型进行运算
@Test
public void test1()
{
byte b = 4;
int i = 3;
// int sum = b + i;
// byte sum = b + i;
short s = 2;
byte b1 = 1;
// (1) 验证成功, byte short char 在运算时默认转化成int 类型进行运算
// short sum = s + b1;
// System.out.println("sum = " + sum);
}
(4) 交换两个变量的方式, 面试题(掌握)
// 思考题1
// 交换两个变量值的话题, 解决方案, 平时使用和面试使用
@Test
public void test1()
{
int a = 10;
int b = 20;
// 方式一: 使用第三发变量存储 工作中使用...
// int tmp = a;
// a = b;
// b = tmp;
// System.out.println("a = " + a + " b = " + b);
// 方式二: 面试专用, 使用 a ^ b ^ b ==> a 的方法
// 效率最高
// a = a ^ b;
// b = a ^ b; // b = a == (a ^ b) ^ b;
// a = a ^ b; // a = b == (a ^ b) ^ a
// System.out.println("a = " + a + " b = " + b);
// 方式三: 用变量相加减的方法
// a = a + b;
// b = a - b;
// a = a - b;
// System.out.println("a = " + a + " b = " + b);
// 方式四: 一句话搞定
b = (a + b) - (a = b);
System.out.println("a = " + a + " b = " + b);
}
(5) 运算符与和或(掌握)
// 逻辑 && || 和 位 的 & 和 | 区分
// && 和 || 的短路效果
// && 出现左边是 false 右边就不执行了
// || 出现左边是 true 右边就不执行了
@Test
public void test2()
{
boolean a = false;
boolean b = true;
System.out.println("(1)");
System.out.println("a = " + a);
System.out.println("b = " + b);
if (a != true || (b = false))
{
// 输出的值 是 true
System.out.println("b = " + b);
}
a = false;
b = true;
System.out.println("(2)");
System.out.println("a = " + a);
System.out.println("b = " + b);
if (b == false && (a = true))
{
System.out.println("a = " + a);
}
}
(6) 面试题
/*
* 面试题1
* (1)
* short s = 1;
* s = s + 1;
* (2)
* short s = 1;
* s += 1;
* */
@Test
public void test1()
{
short s = 1;
// 还是同一个问题
// 变量(short char byte )在运算的时候会被上升为 int
// 类型, 这个时候计算完毕, 但是赋值失败, 类型不符合
// s = s + 1;
s += 1;
System.out.println(s);
}
(7) 位移运算符(要会)
// << 左移: 左边最高位置丢弃, 右边补齐0
// >> 右移: 最高位是0 左边补齐 0; 最高位是1 左边补齐1
// >>> 无符号右移: 无论最高位是 0 还是 1, 左边补齐 0
@Test
public void test1()
{
//<< 把<<左边的数据乘以2的移动次幂
System.out.println(3 << 2);// 12
//>> 把>>左边的数据除以2的移动次幂
System.out.println(24 >> 2);// 6
System.out.println(24 >>> 2);// 6
System.out.println(-24 >> 2);// 6
System.out.println(-24 >>> 2);// 乱码
}
/*
计算出3的二进制：11
00000000 00000000 00000000 00000011
(00)000000 00000000 00000000 0000001100
>>的移动：
计算出24的二进制：11000
原码：10000000 00000000 00000000 00011000
反码：11111111 11111111 11111111 11100111
补码：11111111 11111111 11111111 11101000
11111111 11111111 11111111 11101000
1111111111 11111111 11111111 111010(00) 补码
补码：1111111111 11111111 11111111 111010
反码：1111111111 11111111 11111111 111001
原码：1000000000 00000000 00000000 000110
结果：-6
>>>的移动：
计算出24的二进制：11000
原码：10000000 00000000 00000000 00011000
反码：11111111 11111111 11111111 11100111
补码：11111111 11111111 11111111 11101000
11111111 11111111 11111111 11101000
0011111111 11111111 11111111 111010(00)
结果：
*/
//=======================================================================
(8) 面试题
//=======================================================================
/*
面试题：
请用最有效率的方式写出计算2乘以8的结果?
2 * 8
2 << 3
*/
//=======================================================================
(9) 三目运算符(要会)
--------------------------------------------------------------------------------
// 1. 获得两个数的最大值
// 2. 获得三个数的最大值
// 3. 比较两个整数是否相等
@Test
public void test3()
{
// 3. 比较两个整数是否相等
int m = 20;
int n = 10;
boolean flag = (m == n) ? true : false;
System.out.println(flag);
}
@Test
public void test2()
{
// 2. 获得三个数的最大值
int x = 10;
int y = 30;
int z = 20;
// (1)
int tmp = (x > y) ? x : y;
int max = (tmp > y) ? tmp : y;
System.out.println("max = " + max);
// (2) 一步到位
int max1 = (x > y) ? (x > z ? x : z) : (y > z ? y : z);
System.out.println("max1 = " + max1);
}
@Test
public void test1()
{
// 1. 获得两个数的最大值
int x = 10;
int y = 20;
int max = (x > y) ? x : y;
System.out.println("max = " + max);
}
--------------------------------------------------------------------------------
注意:
// 写一个程序需要考虑:
// (1) 成功的数据
// (2) 错误的错误
// (3) 边界问题
二、switch的使用方法
1. switch(表达式)中表达式的返回值必须是下述几种类型之一：byte，short，char，int，枚举，String；
2. case子句中的值必须是常量，且所有case子句中的值应是不同的；
3. default子句是可任选的，当没有匹配的case时，执行default
4. break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到switch结尾
5. 附加跳出多层循环的方法, goto tab;
三、方法的重载(overload)
1、重载的概念
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
2、重载的特点：
与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。------ 这个和函数签名有关, 函数签名只要函数名和函数参数, 并没有函数的返回值
3. 重载示例
//返回两个整数的和
int add(int x,int y){return x+y;}
//返回三个整数的和
int add(int x,int y,int z){return x+y+z;}
//返回两个小数的和
double add(double x,double y){return x+y;}
public class PrintStream{
public static void print(int i) {……}
public static void print(float f) {……}
private static void print(String s) {……}
public static void main(String[] args){
print(3)；
print(1.2f)；
print(“hello!”)；
}
4. 判断方式:
与void show(int a,char b,double c){}构成重载的有：
a)void show(int x,char y,double z){} //no
b)int show(int a,double c,char b){} //yes
c) void show(int a,double c,char b){} //yes
d) boolean show(int c,char b){} //yes
e) void show(double c){} //yes
f) double show(int x,char y,double z){} //no
g) void shows(){double c} //no
四、体会可变个数的形参
//下面采用数组形参来定义方法
public static void test(int a ,String[] books);
//以可变个数形参来定义方法
public static void test(int a ,String…books);
说明：
1.可变参数：方法参数部分指定类型的参数个数是可变多个
2.声明方式：方法名（参数的类型名...参数名）
3.可变参数方法的使用与方法参数部分使用数组是一致的
4.方法的参数部分有可变形参，需要放在形参声明的最后
public void test(String[] msg){
System.out.println(“含字符串数组参数的test方法 ");
}
public void test1(String book){
System.out.println(“****与可变形参方法构成重载的test1方法****");
}
public void test1(String ... books){
System.out.println("****形参长度可变的test1方法****");
}
public static void main(String[] args){
TestOverload to = new TestOverload();
//下面两次调用将执行第二个test方法
to.test1();
to.test1("aa" , "bb");
//下面将执行第一个test方法
to.test(new String[]{"aa"});
}
五、方法的参数传递
1. 方法，必须有其所在类或对象调用才有意义。若方法含有参数：
Ø形参：方法声明时的参数
Ø实参：方法调用时实际传给形参的参数值
2. Java的实参值如何传入方法呢？
Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。
9647
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
