Java第四章知识点总结

1.抽象的含义

抽象是从被研究对象中舍弃个别的、非本质的或与研究主旨无关的次要特征，而抽取与研究有关的共性内容加以考察，形成对研究问题正确、简明扼要的认识。

2.类与对象

对象是客观事物的抽象，类是对对象的抽象。

对象是类的实例，类是对象的模板。

3.类的域和方法

域：是事物静态特征的抽象。

方法：是事物动态特征的抽象。

class FighterPlane1{
    String name="yysy";
    void init(String _name){
        String name=_name;
        System.out.println(name);
        System.out.println(this.name);
    }
    public static void main(String args[]){
        FighterPlane1 e=new FighterPlane1();
        e.init("yyds");
    }
}

yyds
yysy

注意：init方法中的局部变量name和类的域变量name不同，如果要引用类的域变量，则需要引入this关键字。

4.对象的创建

FighterPlane fp=new FighterPlane();（fp是对象的声明，FighterPlane是对象）

有声明时可以没有对象（例如有遥控器时可以没有电视机）

fp能够操纵对象的原因在于它在栈中保留了堆中的对象的实际地址。

注意：一个文件里只能有一个public类，并且文件名要与public的类名一致。

public class IntClass {
    int value;
}
class RunIntClass{
    public static void modifyValue(IntClass s,int val){
        s.value=val;
    }
    public static void main(String args[]){
        IntClass a=new IntClass();
        modifyValue(a,8);
        System.out.println(a.value);
    }
}

8

public class IntClass {
    int value;
}
class RunIntClass{
    public static IntClass getInstance(){
        IntClass s=new IntClass();
        s.value=8;
        return s;
    }
    public static void main(String args[]){
        IntClass a;
        a=getInstance();
        System.out.println(a.value);
    }
}

8

5.对象数组

首先要先要了解一下数组的声明格式，类型标识符[] 数组名;

例如：int [ ] arr;  String [ ] example;  myclass [ ] mc;  int arr[ ][ ]; int [ ][ ] arr;

注意声明时不可在方括号内指定数组大小，如int [10] arr;是错误的。

然后对数组进行初始化，共三种方法：

一.使用关键字new——可将数组看成一个特殊对象

①数组元素为基本类型

类型标识符 [ ] 数组名=new 类型标识符[数组长度];

例如：int [ ] arr=new int [10];

②数组元素为引用类型

例如：String [ ] example=new String [10];

产生一个具有10个单元的数组对象，每个单元存放的是一个String对象的引用，所有单元的初值为默认值null,此时并未创建具体的String对象。

二.直接在声明的时候进行定义及初始化

例如：String [ ] s={"ab","bc","cd"};Integer results[]={new Integer(3),new Integer(5),new Integer(8)};

注意：这种初始化方法只能写在声明代码中。int [] a;a={1,2,3}是错误的。

三.采用一和二相结合的方式进行初始化

例如：float [] f4=new float[]{1.0f,2.0f,3.0f};

           float [] f4;f4=new float[]{1.0f,2.0f,3.0f};

例题：矩阵转置

public class ArrayTanspose {
    public static void transpose(int [][] m){
        if(m==null)return;
        int temp;
        for(int i=0;i<m.length;i++){
            for(int j=0;j<m.length;j++) {
                if(i>j) {
                    temp = m[i][j];
                    m[i][j] = m[j][i];
                    m[j][i] = temp;
                }
            }
        }
    }
    public static void print(int [][] m){
        if(m==null)return;
        for(int i=0;i<m.length;i++){
            for(int j=0;j<m.length;j++){
                System.out.print(m[i][j]+" ");
            }
            System.out.println(" ");
        }
    }
    public static void main(String args[]){
        int [][] t={{1,2,3},{4,5,6},{7,8,9}};
        print(t);
        transpose(t);
        System.out.println("转置后的矩阵为：");
        print(t);
    }
}

1 2 3  
4 5 6  
7 8 9  
转置后的矩阵为：
1 4 7  
2 5 8  
3 6 9  

6.构造方法的特征

①构造方法的方法名和类名相同。

②不能对构造方法进行指定类型，它有隐含的返回值，该值由系统内部使用；如果指定了返回类型，则该方法就不是构造方法。

7.static

*static方法是类方法，但可以被所有对象访问。调用这个方法时，可采用"对象引用.方法名",也可采用"类名.方法名".

*static方法内部的代码，只能访问类中的static属性或方法，不能访问类中的非static属性或方法（因为他们属于对象）；但非static方法可以访问static属性或方法。

*main方法时特殊的静态方法。

静态代码块：

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

当类被装载的时候，静态代码块被执行，且只被执行一次。