java学习笔记day3
今天被String地址的问题纠缠了好久，最后觉得 一个博客上写的能通顺一点：String直接赋值与使用new的区别：
当String类直接赋值时，如果常量池内存在这个字符串，则s1直接指向常量池的地址，若没有，则先在常量池内创建这个字符串对象，s1直接指向常量池这个字符串的内存地址； 当String类使用new实例对象时，首先在堆里创建这个对象，若是常量池内没这个字符串，则也创建一个，然后堆里的对象的value指向常量池内的字符串。
一：局部变量和实例变量
定义变量是指设定变量的数据类型和变量的名字，
Java语言要求变量遵循先定义，再初始化，然后使用的规则。
作用域：指它的存在范围，只有在这个范围内，程序代码才能访问它。
变量的生命周期是指从一个变量被创建并分配内存空间开始，
到这个变量被销毁并清除其所占用内存空间的过程
局部变量(参数变量也可以看成是局部变量)：
1)位置：定义在方法中或者在方法中的{}
2)使用：先赋值后使用
3)作用域：定义的方法中或者定义的{}中
4)生命周期：从变量的定义到方法调用结束实例变量：
1)位置：定义方法外，类里面
2)使用：系统会进行默认初始化
3)作用域：作用于整个类
4)生命周期：从对象创建的时候到gc回收内存结束局部变量的例子：
public void method1() {
int a = 0; //局部变量，作用域为整个method01方法；
{ int b = 0; //局部变量，作用域为所处的代码块；
b = a;
}
b = 20; //编译出错，b不能被访问；
}
实例变量的例子：
class Test {
private int n1=0;
private int n2=0;
public int add() {
int result = n2 + n2;
return result;
}
}二：操作符:操作符能与相应类型的数据组成表达式，来完成相应的运算。
a)数学运算操作符
+数据类型值相加或字符串连接;
System.out.println(1+2+"a"); //输出3a
System.out.println(1+2.0+"a"); //输出3.0a
System.out.println(1+2.0+"a"+true); //输出3.0atrue
System.out.println("a"+1+2); //输出a12
System.out.println(1+"a"+2); //输出1a2
/整除, 如操作数均为整数，运算结果为商的整数部分
int a1=12/5; //a1变量的取值为2
int a2=13/5; //a2变量的取值为2
int a3=-12/5; //a3变量的取值为-2
int a4=-13/5; //a4变量的取值为-2
int a5=1/5; //a5变量的取值为0
double a6=-12/5; //a6变量的取值为-2.0
double a7=-12/5.0; //a7变量的取值为-2.4
%取模操作符, 如操作数均为整数，运算结果为商的整数部分
int a1=1%5; //a1变量的取值为1
int a2=13%5; //a2变量的取值为3
double a3=1%5; //a3变量的取值为1.0
double a4=12%5.1; //a4变量的取值为1.8000000000000007
b) 赋值操作符：
= :int x=0,i=1,j=1;
=:这里的"="由操作符""和"="复合而成，它等价于 a=ab;
这种复合操作符能使程序变得更加简洁。
/=:a/=b 等价于 a=a/b;
%=:a%=b 等价于 a=a%b;
...
注意：+=和+的区别
如:short a=0;
int b=123456;
a+=b;和a=a+b的区别
+=系统会进行隐式的数据类型转换，向=左边的数据类型进行转换。
a+b会向数据类型高的类型转换
c) 比较操作符
大于
= 大于等于
< 小于
<= 小于等于
以上操作符只适用于整数类型和浮点数类型；
int a=1,b=1;
double d=1.0;
boolean result1 = a>b; //result1的值为false;
boolean result2 = a<b; //result2的值为false;
boolean result3 = a>=d; //result3的值为true;
boolean result4 = a<=b; //result4的值为true;
instanceof: 判断一个引用类型所引用的对象是否是一个类的实例。
该操作符左边是一个对象，右边是一个类名或接口名。形式如下：
如：String str="hello"
System.out.println(str instanceof String);
System.out.println(str instanceof Object);
System.out.println(str instanceof Student); //false
java.lang.Object是所有类的父类，
每一个类都会默认继承Object
子类是一个父类 是is a的关系
d)相等操作符
== 等于
!= 不等于
既可以是基本类型，也可以是引用类型：
基本数据类型比较是真正的数值
引用类型比较的是地址，如果要比较引用类型真正的数据使用equals()方法
如：int a=1,b=1;
System.out.println(a==b); //输出true;
如：String s1="hello";
String s2="hello";
String s3=new String("hello");
String s4=new String("hello");
System.out.println(s1==s2); //true
System.out.println(s3==s4); //false
System.out.println(s1==s3); //false
System.out.println(s3.equals(s4)); //true
e) 移位操作符，针对二进制操作
算术右移位运算，也称做带符号右移位运算。最高为补符号位。
逻辑右移位运算，也称为不带符号右移位运算。
<< 左移位运算，也称为不带符号左移位运算。
f) 位运算操作符
& :与运算，运算规则为：1&1->1, 1&0->0, 0&1->0, 0&0->0;
|:或运算，运算规则为：1|1->1, 1|0->1, 0|1->1, 0|0->0;
^:异或运算，运算规则为：1^1->0, 1^0->1, 0^1->1, 0^0->0;
两个值相同为0,不同为1；
~ : 取反运算, ~1->0, ~0->1;
例如：8>>2====>8/2^2=2
8:0000...00001000
0000.........10 ====>2
8>>>3=====>8/2^3=1
8:0000...00001000
00000000.000001=====>1
8<<2======>8*2^2=32
8:0000...00001000
000000000100000======>32
1&1=1 1&0=0 0&0=0
1|1=1 1|0=1 0|0=0
1^1=0 1^0=1 0^0=0
~1=0
~0=1
8&2=0 8|2=10 8^2=10
~8=
~2=
1010
10===>第三位置1===>14
10===>第二位清0===>8
10===>第一位置反===>11
10===>输出相应的二进制
f) 逻辑操作符
短路操作符，如果能根据操作左边的布尔表达式
就能推算出整个表达式的布尔值，将不执行操作
符右边的布尔表达式；
&&:左边的布尔表达式的值为false, 整个表达式值肯定为false,
此时会忽略执行右边的布尔表达式。
||:左边的布尔表达式的值为true, 整个表达式值肯定为true,
此时会忽略执行右边的布尔表达式。
if(条件1&&条件2){}
if条件1为假，不会执行条件2
if条件1为真，会执行条件2
if(条件1||条件2){}
if条件1为真，不会执行条件2
if条件1为假，会执行条件2
g) 条件操作符
布尔表达式 ? 表达式1 : 表达式2
如果布尔表达式的值为true,就返回表达式1的值,否则返回表达式2的值。
int score = 61;
String result = score>=60?"及格":"不及格";
h)++,--
前++与后++
前--与后--
int a=10;
b=++a =====>a=11,b=11,先计算，后赋值
b=a++ =====>a=11,b=10，先赋值，后计算
System.out.println("a:"+a+" b:"+b);
三.数据类型的转换
1）基本数据类型转换
隐式的数据类型转换：精度小的数据给精度大的数据
强制（显式）的数据类型转换：(type)精度大的数据给精度小的数据
System.out.println((int)(char)(byte)-1);
数据类型在转换的时候注意：
a)如果将精度小的数据转为精度大的数据时。
如果转之前是有符号数，在前面补符号位
如果转之前是无符号数，在前面补0
b)如果将精度大的数据转为精度小的数据时。
从低位窃取位数
2）引用数据类型转换
隐式的数据类型转换：子类转换父类
强制（显式）的数据类型转换：父类转换子类
String str="hello";
Object o=str;
String str2=(String)o;
四.语句
a)条件语句:有些代码只有满足特定条件的情况下才会被执行
1)if...else
a. if后面的表达式必须是布尔表达式，而不能为数字类型，例如下面的if(x)是非法的。
b. 假如if语句或else语句的程序代码块中包括多条语句，则必须放在大括号{}内。
若程序代码块只有一条语句则可以不用大括号{}。流程控制语句(如if...else语句)
可作为一条语句看待。
c.只可能执行一个分支，不可能执行多条分支
2)switch
a. switch后条件的类型必须是byte, short, char或者int;
jdk1.7之后可以使用String类型。
b. 各个case子句的值不同,数据类型必须和switch后条件的数据类型相同；
c. 当switch表达式的值不与任何case子句匹配时，程序执行default子句，
假如没有default子句，则程序直接退出switch语句。
default子句可以位于switch语句中的任何位置。
d. 如果switch表达式与某个case表达式匹配，或者与default情况匹配，
就从这个case子句或default子句开始执行。
假如遇到break，就退出整个switch语句，否则依次执行switch语句中后续的case子句，
不再检查case表达式的值。
e. switch语句的功能也可以用if...else语句来实现。
但switch语句会使程序更简洁，可读性更强。而if...else功能更为强大。
b)循环语句
循环语句的作用是反复执行一段代码，直到不满足循环条件为止。
循环语句一般应包括如下四部分内容：
i)初始化部分：用来设置循环的一些初始条件，
比如循环控制变量的初始值；
ii)循环条件:这是一个布尔表达式，
每一次循环都要对该表达式求值，
以判断到底继续循环还是终止循环。
iii) 循环体：这是循环操作的主体内容，可以是一条语句，也可以是多条语句；
iv) 迭代部分:用来改变循环控制变量的值，
从而改变循环条件表达式的值；
1)for
语法：for(初始化部分；循环条件；迭代部分) {
循环体
}
2)while
语法：[初始化部分]
while(循环条件) {
循环体,包括迭代部分
}
当循环条件为true时，就重复执行循环，否则终止循环；
3)do..while
和while非常类似，只不过先执行循环体，然后再判断循环条件。
语法：[初始化部分]
do {
循环体,包括迭代部分
} while(循环条件);
4)循环语句中流程跳转
a) break: 终止当前或指定循环；
b) continue: 跳过本次循环，执行下一次循环，
或执行标号标识的循环体。
c) label: 标号用来标识程序中的语句，标号的名字可以是任意的合法标识符。
continue语句中的标识必须定义在while、do...while和for循环语句前面；
break语句中的标识必须定义在while、do...while和for循环语句或switch语句前面；五.题目
一：写Test.java，要求如下：
1)传入一个int数，要求清除该数的低8位，高24位不变，将结果以十进制形式输出
2)传入一个int数，要求将该数的低16位置1，高16位不变，将结果以十进制形式输出
3)实现两个int类型变量值的交换，要求不使用中间变量
二：以二进制形式输出一个十进制数
三：写LoopTest.java，分别使用while/do/for循环实现1x2x...x10。
四：创建一个阶乘应用程序Factor.java
功能：一个数X 的阶乘（通常记作X!）等于X*(X-1)*(X-2)*.....*1。例如4!等于4×3×2×1=24。
五：打印出四种形式的九九乘法表
提示：
1、System.out.println()的功能为输出+换行
System.out.print()的功能为输出
2、在适当的位置可以使用'\t'进行对齐操作
形式1：
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
形式2：
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
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*7= 7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*6= 6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*5= 5 2*5=10 3*5=15 4*5=20 5*5=25
1*4= 4 2*4= 8 3*4=12 4*4=16
1*3= 3 2*3= 6 3*3= 9
1*2= 2 2*2= 4
1*1= 1
形式3：
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
形式4：
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
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*7= 7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*6= 6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*5= 5 2*5=10 3*5=15 4*5=20 5*5=25
1*4= 4 2*4= 8 3*4=12 4*4=16
1*3= 3 2*3= 6 3*3= 9
1*2= 2 2*2= 4
1*1= 1
六：1,题目：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？
程序分析：可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去掉不满足条件的排列。
Digit.java
七,判断101-200之间有多少个素数，并输出所有素数。
只能被1和它本身整除的自然数为素数(质数)
Prime.java
八,打印出所有的“水仙花数”，所谓“水仙花数”是指一个三位数，其各位
数字立方和等于该数本身。例如：153是一个“水仙花数”，因为
153=1的三次方＋5的三次方＋3的三次方。
Flower.java
Math.pow(a,3);
a*a*a
九,将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。
对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：
a)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。
b) 如果n不等于i，i能被n整除，则应打印出i的值，
并用n除以i的商,作为新的正整数n,重复执行第一步。
提示：如果一个自然数能写成两个自然数的乘积，那么这两个自然数就叫作原来那个数的因数。
Divide.java
十,求任意两个正整数的最大公约数和(GCD)和最小公倍数(LCM)
辗转相除法的算法为：首先将 m除以 n（m>n）得余数 r，
再用余数r 去除原来的除数，得新的余数，重复此过程直到
余数为 0时停止，此时的除数就是m 和 n的最大公约数。
求 m和 n的最小公倍数: m和 n的积除以(m和 n 的最大公约数)。
GcdLcm.java
十一,求1000以内的完全数
若一个自然数，恰好与除去它本身以外的一切因数的和相等，这种数叫做完全数。
例如，6=1+2＋3
28=1＋2＋4＋7＋14
496=1+2+4+8＋16+31+62＋124
先计算所选取的整数a(a的取值1~1000)的因数，将各因数累加于m，若m等于a，则可确认a为完全数
Perfect.java这些题目在晚自习前写完了，从下午开始，用linux的vi写的有点慢，加油加油