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
4000
;

}

和上面的很相似，都是关于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");"这里显示有错。

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

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的类型特殊处理，可以理解为传值，最后的操作不会修改实参对象。