【java】基础中的杂乱总结（二）

1 内部类进阶

package package8;
//原则：先用内部类写  之后由于内部类匿名无法引用  用其继承的父类或实现的接口名
//再复写所有的抽象方法即可（是所有，否者还是抽象的，无法创建对象）
interface Inter{
    public abstract void method();
}
class Demo{
    public void function(){
        new Inter(){
            public  void method(){
                    System.out.println("定义的匿名内部类中的方法");
            }
        }.method();
    }
}
class Test{
    public static void main(String[] args){
        Demo d=new Demo();
        d.function();
        show(new Inter(){
            public void method(){
                System.out.println("以接口作为参数成功");
            }
        });  //大括号，括号，分号  注意别漏写
    }
    public static void show(Inter in){  //多态   自动上转型
        in.method();
    }
}

运行结果：

定义的匿名内部类中的方法

以接口作为参数成功

2 java 数组的一些问题

（1）一维数组

int a[]或int[] a; a=new int[5]; 相当于int a[]=new int[5];

说明：Java对所有使用new运算符动态分配的存储单元都进行初始化工作，变量根据所属的数据类型相应获得初值

short，int，byte，long 0

char ‘\u0000’

float 0.0f

double 0.0

boolean false

引用数据类型 null

（2）数组是引用类型

（3）一个数组变量保存一个数组的引用，即该数组占用的一块存储空间的首地址，长度及引用计数等特性，两个数组变量之间是引用赋值，传递的是地址等引用特性，没有申请新的存储空间。

int a[]=｛1，2，3，4，5｝，b[];

b=a；（之后对b的操作同时改变a的元素值）

可以使用关系运算（==，！=）判断两个数组是否引用同一个数组

（4）二维数组

int []mat[]; int [][]mat; int mat[][]=new int[2][3];

mat.length 返回二维数组的长度，即二维数组的行数

mat[0].length 返回一维数组的长度，即二维数组的列数

（5）不规则的二维数组

由于Java的二维数组采用动态引用的模型，二维数组mat中每一个一维数组mat[0]，mat[1]是分散存储的，故可以多次分配。

如：int mat[][]=new[2][];

mat[0]=new int[2];

mat[1]= new int[3];

3 访问控制

类有2种访问控制权限，类中成员有4种访问控制权限

（1）类的访问控制权限：

　　　　公有：所有类访问

　　　　缺省：无修饰符，可被当前包中的类访问

　　　　注意：一个源程序文件可以声明多个类，但用public的修饰符的类只能有一个，且该类名必须与文件名相同。

（2）类中成员的访问控制权限

　　　　一个类中的所有成员都可以被本类的代码访问，为了控制其他类的访问，类的成员有4种访问控制权限。

　　　　　　　　　　　　　　　当前类当前包 (其他包的)子类所有类

　　　　private（私有） yes

　　　　缺省 yes yes

　　　　protected（保护） yes yes yes

　　　 public（公有） yes yes yes yes

注意：缺省为当前包中可见，protected为子类中可见，另外，public等权限修饰符不能用于修饰方法体中的局部变量，因为局部变量的作用域仅限于当前方法，对其他类不可见。

4 格式化Date的方法

@Test
    public void fm(){
        Date d = new Date();
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(df.format(d));
    }

有了guava的joda time以后似乎已经不推荐这么写了（see DateTime）

5 一个实例来看继承时成员变量与成员方法的访问情况

package inherite;

class Father{
    public Father(){
        System.out.println("i am father");
    }

    public int age = 40;
    String name ="father";
    public void teach(){
        System.out.println("teaching");
    }
}

class Son extends Father{

    public Son(){
        System.out.println("i am son");
    }
    public int age =15;
    public void study(){
        System.out.println("studying");
    }

    public void teach(){
        System.out.println("teachinghahah");
    }
}

public class Test {
    public static void main(String[] args) {
        Son son = new Son();
        System.out.println(son.name);
        System.out.println("-----------");

        Father f = new Son();  //上转型时成员变量看父类，成员方法看子类
//        f.study();  //这句编译失败
        f.teach();
        System.out.println(f.name);
        System.out.println(f.age);

        System.out.println("-----------");
        Son s = (Son) f;
        s.study();
        s.teach();
        System.out.println(s.age);
    }
}

运行结果：

i am father
i am son
father
-----------
i am father
i am son
teachinghahah
father
40
-----------
studying
teachinghahah
15

秒客网

【java】基础中的杂乱总结（二）

相关文章