加载中...

1.

 两个整数相除时，除数不能为0；

 但是其中有一个是浮点数时，除数可以是0或0.0；

  System.out.println(5/0.0);//Infinity，无穷大
  System.out.println(-5.0/0);//-Infinity，负无穷大

2.

取余运算也是一样的，两个整数是不能对0取余的；要有浮点数的参与，且结果是非数；
  System.out.println(-5.0%0);//NaN，非数
  System.out.println(-5%0.0);//NaN，非数

另外：取余运算的结果的符号和被取余的那个数的符号一致；
  System.out.println(-5%2);//-1;
  System.out.println(5%-2);//1;
  System.out.println(-5%-2);//-1;

3.

自增运算的两种形式：

int a=5;

int b=0,c=0;

b=a++ +2;

c=++a +2;

syso('b='+b+';c='+c);

结果是：b=7;c=9

只要记住一句话，然后细心就行了；

是先自增还是先运算；

对于b=a++

java中的每个字符串都是一个String类的对象；并且String类是一个典型的不可变类，下面简单看一下这个类的源代码：

public final class String
    implements java.io.Serializable, Comparable, CharSequence
{
   
    private final char value[];

   
    private final int offset;

   
    private final int count;
·········

·········

}

底层使用数组来存放的，这个类是用final修饰的，他的成员变量几乎也都是fianl定义的常量，所以String对象一旦被创建出来就不能被改变！

String str='hello';

String str1='he'+'llo';

syso(str==str1);//结果是true；

str和str1是两个对象，为什么会返回true？

因为java使用常量池来缓存字符串常量值；'hello','he','llo',他们都是字符串常量值；当程序第一次使用某个字符串直接量时，java就是用常量池来缓存该字符串直接量；所以'he

1.

当一个表达式中包含了多种数据类型时，整个算术表达式的数据类型将会自动提升；

byte,short,char,(int)将被提升为int;

比如：

short s=12;

//编译通不过；因为这个表达式的结果是int型的，不能赋给short型的变量，除非强制转换类型为short；

s=s+2;

但是这样是可以通过的：

s+=2;

2.

当表达式中只有一种类型，那么运算后的结果还是原来的类型；比如：

int i=30;

i/4 的结果是7，不会是一个浮点数的结果；

如果想让结果是小数，那么可以让其中一个是浮点数类型的，那么结果就会自动类型提升了；比如：

i/4.0 的结果是（double类型的）7.5 ；

3.

基本类型和字符串相加结果是字符串；比如:

String str= 'Hello:'+12;

一道面试题：short a = 128, byte b = (byte)a，问打印的a,b分别是多少？
key：a=128,b=-128
byte类型的数据取值范围是：-128-127，
例如：byte a=(byte)128;
  byte b=(byte)(-129);
a和b得值分别为-128和127.
这个是Java编码方式决定的，Java中正数用源码表示，负数用补码表示，第一位是符号位。

所以对于128和-129，他们的编码分别是：

0000 0000 0000 0000 0000 0000 1000 0000

和

1111 1111 1111 1111 1111 1111 0111 1111

使用强制类型转换之后得到的a和b分别是1000 0000和0111 1111。

对于a来说，1000 0000是负数（第一位为1），它的绝对值是1000 0000即128，

而对于b来说，0111 1111是正数，值为127。

强制转换的截位本身就带来数据的损失，所以出来的结果比较怪也是正常。
最初刚刚开始的时候，我怎么也弄不明白java中为什么可以到得到-128的值，经过自己在网上查找一些相关的资料之后，终有所悟

编译不带包名的java源文件很容易，就是先javac XX.java  ;运行就是 java  XX；

当源文件带有包名时就不能这样了，可以这样编译：

javac -d . Reflect2.java ReflectPoint.java

说明Reflect2类中用到了ReflectPoint类，其中

 -d 是javac 的参数

点和-d之间有个点，且不能省去；表示在当前目录下生成包和字节码；你可以指定目录比如当前路径下有一个cc文件，可以这样：javac -d .\cc Reflect2.java ReflectPoint.java  要确保cc文件的存在；

运行：

java com.study.Class.Reflect2

附：

Reflect2源代码：

package com.study.Class;

..........

ps:即使是不带包名，也可以这样编译；

在java中定义一个类用class;

接下来要说的是java中的一个类名叫Class；

一个类是描述了一类事物的属性，和功能，具体的属性由对象决定，那么java里的所有类也是一类事物，就通过

Class来描述，类有什么属性呢？比如类属于哪个包，它的父类、子类等，那么这些就都是Class类的属性了...

那么Class类的一个对象就对应了一个java类的字节码，用到哪个类时就会把哪个类的字节码加载到内存里来，

比如用到了Date类，这个可以和这样写：Class c=Date.class;这份字节码就是Class类的一个对象；或者用Date

的对象获取字节码：date.getClass();

上面两种方法都是类已经加载到内存了。而下面这个方法不需要；

Class.forName('java.lang.String');

这个方法有两种得到字节码的方式，如果内存里还没有加载这个类的字节码，就先加载进来然后返回；如果内存

里已经有了这个类的字节码，那么就直接返回；

综上所述：得到一个类的字节码有三种方式:

类名.class;

对象.getClass();

Class.forName('类名');

举例说明：

  String str='abc

java起初抛弃了C语言里的枚举，由于需要就在JDK1.5版本加上了枚举功能；

首先什么是枚举，其实枚举就是一个列表，有些值或者说是属性我们有的时候就想给你一个固定的值让你选择，

而不是自己控制，比如对于星期来说，就只能是“星期一”到“星期日”，不能任由你的喜爱整出一个“星期

八”来！也不可能有两个“星期一”，这也不符合实际，这写可以通过枚举来实现；

1.最简单的枚举：

public enum WeekDay{
  SUN,MON,TUE,WED,THI,FRI,SAT;

 }

其实最后一个分号可加，可不加，当这个枚举列表下面还有内容时（方法等）就得加上了；所以加上；

使用：

  WeekDay wd=WeekDay.MON;
  WeekDay wd2=WeekDay.TUE;
  System.out.println(wd);//输出MON
  System.out.println(wd.ordinal());//排行从0开始输出1；
  System.out.println(wd.valueOf('SUN'));//字符串转换为枚举元素；输出SUN
  
  //所有元素放到数组里，接着就可以遍历

在java中，所有的对象都是可以进行比较的，还可以以字符串的形式打印出来，这就是toString()方法，所有类都是Object类的子类；

在Object类中有一个toString（）方法，因此所有的对象都自然而然地直接或者间接地继承来了这个方法，当我们把一个对象直接输出时，其实就是调用了toString（）方法，有的时候我们想自定义这个打印的信息时就可以覆盖这个方法；因为一个对象的toString（）方法默认是打印【这个对象所属的类@哈希码值】，这个对于我们来说一般是没有意义的....

例如：

class A{

//覆盖toString方法；
 public String toString(){
  return 'A对象' ;
 }
 private void mian() {
  // TODO Auto-generated method stub
  System.out.println(new A());//直接打印A的对象，实际上先去调用它的toString()方法，然后打印；

 }
}

运行结果可想而知：

A对象

首先回顾java的数据类型；

java基本数据类型：byte,short,int,float,double,char,boolean

引用类型：数组，String，对象，接口

其中java的基本数据类型都有各自对象的封装类；

//自动装箱与拆箱
 public static void autoBox()
 {
  Integer intObj=3;  //int的封装类；
  System.out.println('自动拆箱：'+(intObj+3));
  //自动装象
  Integer Obj1=13;
  //静态方法
  Integer Obj2=13;

  //把13包装成对象；这个不是自动装箱
  Integer Obj3=Integer.valueOf(13);

  //数字比较小，而且经常使用，所以他们共享一个就行了；
  //数字大的时候，就不经常用了，所以不共享；
  Integer Obj4=128;
  Integer Obj5=128;
  //享元模式，-128——127之间的数共享，
  System.out.println(Obj1==Obj2); //true
  System.out.println(Obj2==Obj3);

增强的for循环使用时更简单一点，这个可以看看：

举例：

 public static void printf()
 {
  int sum=0;
  int args[]={1,2,3,4};
  for(int arg:args)
  {
   sum+=arg;
  }
  System.out.println('增强版for循环：'+sum);
  
  int a[]={1,2,3,4,5,6};
  char c[]={'a','b','c','d'};
  String s[]={'abc','sdfds','jrt','gsdfg'};
  
  for(int i:a){
   System.out.println(i);
  }
  for(char ch:c){
   System.out.println(ch);
  }
  for(String str:s ){
   System.out.println(str);
  }
 }