java的一些散知识点

一．关于java中的++的问题，++x是先加再用，而x++是先用在加，以下的例子说明了这个问题

public class MyText {  public static void main(String arg[]){int x=0,y=0,k=0;for(int z=0;z<5;z++){  /*1.因为是&&的逻辑运算符，所以从左至右的进行判断，如果一遇到不真的后面的逻辑语句就不执行所以第一次循环时，只计算了++x，因为++x的值为1，是假的，所以不算++y了,2.诱因k++是先用k再加，所以判断的时候，k不会自加3.综上所述，if语句里的代码一次也没有执行*/if((++x>2)&&(++y>2)&&(k++>2)){x++;++y;k++;}System.out.println("第"+(z+1)+"次");System.out.println("x="+x+" "+"y="+y+" "+"k="+k);}}}

输出的结果：

第1次

x=1 y=0 k=0

第2次

x=2 y=0 k=0

第3次

x=3 y=1 k=0

第4次

x=4 y=2 k=0

第5次

x=5 y=3 k=1

二．Java中静态变量是属于类的，当然也可以使用对象的方法对静态变量进行操作，但是操作后的值还是类的，不属于类的实例化的对象。

例：

public class MyText { //静态变量是可以操作的，而且操作后的值也属于类，任何这个类的实例化对象引用它，都会输出类的静态变量private static int i =1;public int getNext(){return ++i;//++i是先加（运算）在执行赋值（=、return等操作）}public static void main(String[] args) {MyText my =new MyText();MyText my1=new MyText();//my对象调用getNext()方法，静态变量i的值会变成2my.getNext();//my1再getNext()时，静态变量i会直接从2加1，而不是从1再加1;System.out.println(my1.getNext());//输出结果为3}}

三．Java的类成员变量定义之后，如果是非final修饰的成员，java系统会自动的给变量赋予初值。

string类型赋予null，整型赋予0，小数赋予0.0，char类型赋予\u0000，boolean类型会默认为false。

但是如果是java修饰的成员，则必须初始化，可以在定义时初始化，也可以在构造器和出事化块里初始化。

实例变量是在非静态初始化块和构造器里初始化，要可以在定义时初始化；静态变量则只能在静态初始化块里和定义时初始化。

对于局部变量，则一定要程序员显示声明，系统不会为之赋予默认值。

public class MyText { boolean a;//boolean值为属性时，系统一般默认为falseint b;//默认为0，整型的byte，int，short，long都为0float c;//默认为0.0f，要是是double就是0.0dchar d;//默认为\u0000final int e;//定义了final值之后，必须在定义时、初始化块或者构造器中进行初始化    final int f;//final类型是系统不会默认赋值。    String  g;//对于参考型的，出事值都为null    {//这里是在初始化块里把e初始化了    e=3;}    MyText()//这是在构造器里把f初始化了    {    f=2;    }public static void main(String[] args){  MyText my=new MyText();  //下面输出a-g七个不同的变量  System.out.println(my.a);//输出false      System.out.println(my.b);//输出0      System.out.println(my.c);//输出0.0      System.out.println(my.d);//输出一个空格，因为\u0000是Unicode中的空格      System.out.println(my.e);//输出3，初始化块里赋了值      System.out.println(my.f);//输出2，构造器里赋了值      System.out.println(my.g);//输出null}}

四．对于java中的==和equal()方法

在基本类型里，如果两个类型不同，但是都是数值类型，只要是值相等，那么返回的值就是true（注意：==是逻辑运算符，返回的是一个boolean类型的值）

equal（）这个方法是String类中的方法。

public class MyText {public static void main(String[] args)   {    int i=65;char c='A';float f=65.0f;    //因为A对应的ASC∏码相同，所以输出的是true    System.out.println(i==c);    //下面也是输出的是true    System.out.println(i==f);    //下面也是输出的是true    System.out.println(c==f);    //下面定义两个String的对象，但是它们都是引用常量池的hello常量，所以返回值为true    String str1="hello";    String str2="hello";    System.out.println(str1==str2);    //如果是这样定义，则str3和str1就不是同一个对象了，因为new String创建了两个对象    String str3=new String("hello");    //下面将输出false    System.out.println(str1==str3);    //但是如果调用的是String的equal的对象，那么就能返回true    System.out.println(str1.equals(str3));  }}

五．在继承的时候，子类是不能继承父类的构造器的，但是要是子类在实例化的时候和父类实例化的时侯做得事都一样，则在子类构造器里，可以用super（）货super（形参列表）来调用父类的构造器。

public class MyText {      int text;      String one;    MyText(int text,String one)    {     this.text=text;     this.one=one;     }}public class MyText1 extends MyText{    MyText1(int text,String one)   {   //此处使用super关键字调用父类的方法  super(text,one);   }   //定义一个方法，用于输出类的信息   public void show()   {   System.out.println(super.text+" "+super.one);   }   public static void main(String arg[])   {   MyText1 my=new MyText1(1, "one");   my.show();   }}

这时将输出1

六．多态是指编译是类型和运行的不同而产生的现象

多态存在的三个条件

1.      有继承

2.      有重写

3.      父类引用指向子类对象

public class Person { public String name="我是傻逼";  //父类被子类覆盖的方法  public void test()  {  System.out.println("父类被覆盖的方法");  }  //父类自己的方法  public void father()  {  System.out.println("父类自己的方法");  }}public class MyText extends Person{public int name=6;//子类覆盖父类的方法public void test(){  System.out.println("子类覆盖父类的方法");}    //子类的自己的方法public void son(){System.out.println("子类的普通方法");}public static void main(String[] args) {  //java允许子类的实例，赋给父类的引用变量，父类的引用指向子类对象       Person p=new MyText();       //下面会输出的是父类的变量值，成员变量调用时，调用的是父类的变量       System.out.println(p.name);       p.father();       //下面会调用的是子类的方法，而不是父类的方法，若有子类的方法覆盖了父类的方法，则优先调用父类的方法       p.test();       //引用p不能调用子类的方法，调用时，会出现编译出错。}}

输出的结果为：

我是傻逼

父类自己的方法

子类覆盖父类的方法

七.     判断实例

public class MyText extends Person{  //instanceof只能计算继承了某个接口和类的实例运算，没有继承，则不能执行运算。public static void main(String[] args) {       Object hello="Hello";       //String继承了Object类，所以返回值为true       System.out.println("字符串是否是Object的实例"+(hello instanceof Object));       System.out.println("字符串是否是String的实例"+(hello instanceof String));       //Math继承了Object类，所以可以进行instanceof的运算       System.out.println("字符串是否是Math的实例"+(hello instanceof Math));       //String实现了Comparable的接口，所以返回值为true       System.out.println("字符串是否是Comparable的实例"+(hello instanceof Comparable));}}