类和对象（上）

类和对象

对象与对象引用的区别是什么?

public class hello {
    String name = "su35";
    int missileNum;
    void init(String name){
        this.name = name;
        System.out.println(this.name);
    }
    public static void main(String[] arg){
        hello fp = new hello();
        fp.init("f35");
    }
}

1. 创建对象： new hello(); （分配在堆上）
2. 声明一个对象引用： hello fp ; （分配在栈上）
3. 初始化对象引用： p1 = new hello()

对象作为参数传递的特点是什么？

基本数据类型作为参数传递是值传递，而对象是引用传递

class intclass{
    int value;
}
public class hello {
    public static int a,b;
    public static void chuandi (intclass a,int x){
        a.value=x;
        x++;
    }
    public static void main(String[] arg){
      intclass s=new intclass();
      int y=6;
      chuandi(s,y);
      System.out.println(s.value+" "+y);//输出结果是6  6
    }//s的value变为6，但是y没有加加，x++只是对形式参数++
}

对象初始化顺序是怎样的？

在没有继承的条件下，实例化一个对象，构造的先后顺序是，静态成员变量>静态初始化块>成员变量>初始化块>构造方法
一般顺序为 先静态，后非静态，先变量，后初始化块，再是构造方法

class intclass{
    public intclass(String str){
        System.out.println(str);
    }
}
public class hello {
    intclass S=new intclass("成员变量");
    static intclass a=new intclass("静态成员变量");
    {
        System.out.println("初始化块");
    }
    static {
        System.out.println("静态初始化块");
    }
    hello(){
        System.out.println("构造方法");
    }
    public static void main(String[] arg){
      new hello();
    }
}

输出结果：
静态成员变量
静态初始化块
成员变量
初始化块
构造方法

类的static字段与非static字段的区别是什么？

1.用static修饰符修饰的数据成员是不属于任何一个类的具体对象，而是属于类的静态数据成员。
2.它被保存在类的内存区的公共存储单元中,而不是保存在某个对象的内存区中。因此,一个类的任何对象访问它时，存取到的都是相同的数值。
3.访问方式为通过类名加点操作符来访问，也可通过对象引用来访问。
4.静态数据成员仅在类加载时进行初始化，且只执行一次初始化
一般是很多类对象共用某个变量时，则用到static数据成员

class intclass{
    public intclass(String str){
        System.out.println(str);
    }
}
public class hello {
    static int a;
    int c;
    hello(){
        c=0;
    }
    hello(int x){
        a=x;
        c=x;
    }
    public static void main(String[] arg){
      hello A=new hello(5);
      hello B=new hello();
      hello.a++;
      A.c++;
      System.out.println(A.a+" "+A.c);
      hello.a++;
      B.c++;
      System.out.println(B.a+" "+B.c);
    }
}

输出结果：
6 6
7 1
ps：
static方法
static方法是类方法，但可以被所有对象所访问，引用这个方法时，可以使用对象名做前缀，也可以使用类名做前缀
static方法内部的代码，只能访问类中的static属性或方法，不能直接访问类中的非static属性或方法（因为那是对象方法），但非static方法（对象方法）可以访问static数据成员
main方法是特殊的静态方法，是Application程序入口点，必须写成public static void main(String [] args)的形式。
当首次访问某类的静态字段或静态方法时，会加载该类(.class)，并执行静态初始化语句

static int method(int x){
    ...
}

static代码块
一个类中可以使用不包含在任何方法体中的静态代码块，当
类被装载时，静态代码块被执行，且只被执行一次，静态代
码块经常用来对类中定义的属性进行初始化。

class Test {
   static int value ;
   static {  
            value = 3;
            System.out.println("value="+value); 
   }
   public static void main(String[] args){   }
}

Java中final修饰符都有什么作用？

1.final修饰属性，则属性为常量。
2.如果修饰方法，则该方法在子类当中不能被覆盖（见多态一节），可防止任何继承类修改此方法，保证了程序的安全性和正确性。
3.final修饰类，则该类不能被继承。

Java数组

一维数组的声明格式：
类型标识符[] 数组名；

二位数组的声明格式：
类型说明符 数组名[ ][ ]；

int[]  arr;
String[]  example;  
myClass[]  mc ; 

float[10] arr; 是错误的
正确的数组声明方式有三种

public class shuzu {
    public static void main(String [] arg){
        int a[]={1,2,3};//1.数组对象，直接在声明的时候进行定义及初始化，这种写法只能写在声明代码中
        
        float b[]=new float[]{1.0f,2.0f,3.0f};//2.数组元素为引用类型
        String[] bb=new String[5];
        bb[0]=new String("hello");
        for(int i=0;i<10;i++){
            System.out.println(bb[i]);
        }
        //输出结果为hello,null,null,null,null
        未初始化的String默认为null,int默认为0。

       // 3.   12方式结合
        char c[];
        c=new char[]{'a','b','c'};
        for(int i=0;i<3;i++){
            System.out.println(a[i]+" "+b[i]+" "+c[i]);
        }
    }
}

特别的二维数组的，当只定义第一维维数时，另一维的维数可以不一样
 int[][] arra;
 arra =new int[3][];
 arra[0]=new int[3];
 arra[1]=new int[2];
 arra[2]=new int[1]; 

Java数组元素类型为基本数据类型和引用类型时，有什么不同？

前者数组中的元素全部为基本数据类型，后者存储的为对象的地址。
比如：
Cell[] cs=new Cell[10];
当声明完成后，数组对象的地址为NULL