Java深入理解知识点 类型转换

1. 空引用（null）只能被转换成引用类型，不能转换成基本类型，因此不能把null赋值给基本数据类型的变量
class NULL{
}

NULL n=（NULL）null  对 null是Object类 可以强转 可以赋值给任何引用变量

2. java 数据类型转换

 

boolean 只能赋值给boolean类型
从左到右

 System.out.println(3+4+"Java");输出7Java

 System.out.pringln("java"+3+4)；则输出java34

溢出转换

int value =233； byte svalue=（byte）value； sualue=-23；当溢出的时候会变为负数

32位的int强制转换成8位的byte 截断前面的24位，只保留右边的8位，最左边的1位符号位 表示为负数

补码-1=反码；反码取反=原码 所以 10010111 byte值为-（16+4+2+1）=-23；

默认基本数据类型

float a=5.6；错误 5.6默认为double类型 改成 float a=（double）5.6;

类型自动提升

short value=5； //value会自动提升为int类型

value-=2；//发生错误 int 类型给short会错误

int a=3; char c='a'; byte b=40; double=".314";

double result=b+c+i*d //result 值为144.22 强转成最高等级操作

 但是 int a1=4； int a2=a1/a； //值为int

System.out.pringln("Hello"+"a"+7);//Helloa7

System.out.pringln("a"+7+"Hello");//104Hello 将a转换成ascss码97

String str1="hello";
String str2="hello";
String str3= new String("hello");

str1.equal(str2); 的结果为 true
str1 == str2 的结果也为true

str1.equal(str3)；的结果为true
str1 == str3; 的结果为false;! 如果new了对象 肯定地址发生了改变

1.abstract class Name {
private String name;
public abstract boolean isStupidName(String name) {}
}
大侠们，这有何错误?
答案: 错。abstract method必须以分号结尾，且不带花括号。
2.
public class Something {
void doSomething () {
private String s = "";
int l = s.length();
}
}
有错吗?
答案: 错。局部变量前不能放置任何访问修饰符 (private，public，和protected)。final可以用来修饰局部变量
(final如同abstract和strictfp，都是非访问修饰符，strictfp只能修饰class和method而非variable)。
3.
abstract class Something {
private abstract String doSomething ();
}
这好像没什么错吧?
答案: 错。abstract的methods不能以private修饰。abstract的methods就是让子类implement(实现)具体细节的，怎么可以用private把abstract
method封锁起来呢? (同理，abstract method前不能加final)。
4.
public class Something {
public int addOne(final int x) {
return ++x;
}
}
这个比较明显。
答案: 错。int x被修饰成final，意味着x不能在addOne method中被修改。
5.
public class Something {
public static void main(String[] args) {
Other o = new Other();
new Something().addOne(o);
}
public void addOne(final Other o) {
o.i++;
}
}
class Other {
public int i;
}
和上面的很相似，都是关于final的问题，这有错吗?
答案: 正确。在addOne method中，参数o被修饰成final。如果在addOne method里我们修改了o的reference
(比如: o = new Other();)，那么如同上例这题也是错的。但这里修改的是o的member vairable
(成员变量)，而o的reference并没有改变。
6.
class Something {
int i;
public void doSomething() {
System.out.println("i = " + i);
}
} 
有什么错呢? 看不出来啊。
答案: 正确。输出的是"i = 0"。int i属於instant variable (实例变量，或叫成员变量)。instant variable有default value。int的default value是0。

class Something {

public void doSomething() {

public int i;//错误编译不过去 修饰符为成员变量而用，方法里的变量使用范围为该方法，别的方法不能调用，除非用final定义 内部方法可以使用 而且只有成员变量 在类里定义的变量才会默认赋值，方法里定义的变量不会有默认赋值

System.out.println("i = " + i);
}
}
7.
class Something {
final int i;
public void doSomething() {
System.out.println("i = " + i);
}
}
和上面一题只有一个地方不同，就是多了一个final。这难道就错了吗?
答案: 错。final int i是个final的instant variable (实例变量，或叫成员变量)。final的instant variable没有default value，必须在constructor (构造器)结束之前被赋予一个明确的值。可以修改为"final int i = 0;"。
8.
public class Something {
public static void main(String[] args) {
Something s = new Something();
System.out.println("s.doSomething() returns " + doSomething());
}
public String doSomething() {
return "Do something ...";
}
}
看上去很完美。
答案: 错。看上去在main里call doSomething没有什么问题，毕竟两个methods都在同一个class里。但仔细看，main是static的。static method不能直接call non-static methods。可改成"System.out.println("s.doSomething() returns " + s.doSomething());"。同理，static method不能访问non-static instant variable。
9.
此处，Something类的文件名叫OtherThing.java
class Something {
private static void main(String[] something_to_do) { 
System.out.println("Do something ...");
}
}
这个好像很明显。
答案: 正确。从来没有人说过Java的Class名字必须和其文件名相同。但public class的名字必须和文件名相同。
10．
interface A{
int x = 0;
}
class B{
int x =1;
}
class C extends B implements A {
public void pX(){
System.out.println(x);
}
public static void main(String[] args) {
new C().pX();
}
}
答案：错误。在编译时会发生错误(错误描述不同的JVM有不同的信息，意思就是未明确的x调用，两个x都匹配（就象在同时import java.util和java.sql两个包时直接声明Date一样）。对于父类的变量,可以用super.x来明确，而接口的属性默认隐含为 public static final.所以可以通过A.x来明确。
11.
interface Playable {
void play();
}
interface Bounceable {
void play();
}
interface Rollable extends Playable, Bounceable {
Ball ball = new Ball("PingPang");
}
class Ball implements Rollable {
private String name;
public String getName() {
return name;
}
public Ball(String name) {
this.name = name; 
}
public void play() {
ball = new Ball("Football");
System.out.println(ball.getName());
}
}
这个错误不容易发现。
答案: 错。"interface Rollable extends Playable, Bounceable"没有问题。interface可继承多个interfaces，所以这里没错。问题出在interface Rollable里的"Ball ball = new Ball("PingPang");"。任何在interface里声明的interface variable (接口变量，也可称成员变量)，默认为public static final。也就是说"Ball ball = new Ball("PingPang");"实际上是"public static final Ball ball = new Ball("PingPang");"。在Ball类的Play()方法中，"ball = new Ball("Football");"改变了ball的reference，而这里的ball来自Rollable interface，Rollable interface里的ball是public static final的，final的object是不能被改变reference的。因此编译器将在"ball = new Ball("Football");"这里显示有错。

1.  为什么接口中的变量都用final修饰（常量）  
2.  * 因为接口本身就是用来定义一个标准、规范，是用来设计用户可用的细节（public）且不能随意更改的（final） 
3.  * 那么接口中的任何东西都应该被定义成统一，那么定义的数值应该是常量  
4.  * 再次思考：假如接口中可以定义非final，而仅仅是public和static修饰的，那么被实现的类可以随便修改（实现类中的static块中），这样会造成标准不统一 
5.  * （是不是有点牵强附会？）。   
6.  *   
7.  * 接口还是不要随意更改，如果可以随意更改会造成很大的麻烦，比如一个接口被很多类实现，那么修改接口后，还必须修改实现类，麻烦程度不言而喻。 
   

a = a + b 与 a += b 的区别(答案)
+= 隐式的将加操作的结果类型强制转换为持有结果的类型。如果两这个整型相加，如 byte、short 或者 int，首先会将它们提升到 int 类型，然后在执行加法操作。如果加法操作的结果比 a 的最大值要大，则 a+b 会出现编译错误，但是 a += b 没问题，如下：
byte a = 127;
byte b = 127;
b = a + b; // error : cannot convert from int to byte
b += a; // ok

3*0.1 == 0.3 将会返回什么？true 还是 false？(答案)  3*0.1输出0.30000000000000004
false，因为有些浮点数不能完全精确的表示出来。. 主要问题是，你用十进制去想，0.7 是一个能准确表示的小数，而二进制却是循环小数。

 

java 参数传递规则

（1）基本数据类型传值，对形参的修改不会影响实参；
（2）引用类型传引用，形参和实参指向同一个内存地址（同一个对象），所以对参数的修改会影响到实际的对象；
（3）String, Integer, Double等immutable的类型特殊处理，可以理解为传值，最后的操作不会修改实参对象。