Java学习注意事项

一个Java文件中可以包含多个类。

如果有public类，则文件名必须和public类一样。

例如：

class Pie {
   void f(){
       System.out.println("Pie.f()");
   }
}

class Cake {
   public static void main(String[] args){
       Pie x = new Pie();
       x.f();
   }
}

class Cake1 {
       public static void main(String[] args){
           Pie x = new Pie();
           x.f();
       }
    }

该文件名可以是Cake2.java或者其它。但如果该文件中有public 类，则文件名必须和public 类名一样。

上述文件编译产生如下的文件：

编译和运行命令如下：

 

1 关于类的访问权限控制：public 或者什么都不写（包访问权限，其它包的类不能访问该类）。

2 方法和字段的访问权限顺序从大到小：Public,  protected,  默认(包访问权限),  private。

2.1 protected 修饰的成员，如果其它package中的类继承了该类，就可以访问该成员。比默认的权限高。

 

3 使用final关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。

4 由于final变量和static变量可以说都只能存一个数据，他们惟一的区别是static变量是属于类的，是类变量，只会被加载一次。

5 final和abstract 修饰的类，第一个不能继承，第二个继承必须实现存在的abstract方法。

6 abstract方法所在的类必须用abstract修饰。abstract修饰的类不能实例化，可以不存在抽象方法。

 

 

关于final

使用final的原因有两个。效率/设计。早期的编译器会针对final方法，进行特殊的优化。但是现在的编译器不推荐用户使用final关键字，

编译器和JVM会去处理相关的效率问题。

特别的，final方法不能被覆盖。因为private方法是不能够继承的，所以private 方法隐式的是final的。

"覆盖"只有在某方法是基类的接口的一部分时才会出现。如果某方法为private，它就不是基类的接口的一部分。

由于private方法无法触及而且能有效的隐藏，所以除了把它看成是因为它所属的类的组织结构的原因而存在外，其他任何事物都不需要考虑到它。

 

继承的初始化顺序

 

package reusing;
class Insect{
    private int i = 9;
    protected int j;
    public Insect() {
        System.out.println("i = " + i + ", j = " + j);
        j = 39;
    }
    private static int x1 = printInit("static Insect x1.initalized");
    static int printInit(String s){
        System.out.println(s);
        return 47;
    }
}
public class Beetle extends Insect{
    private int k = printInit("Beetle.k initalized");
    public Beetle(){
        System.out.println("k = " + k);
        System.out.println("j = " + j);
    }
    private static int x2 = printInit("static Beetle x2.initalized");
    public static void main(String[] args){
        System.out.println("Bettle Constructor");
        Beetle b = new Beetle();
    }

    /*
     * static Insect x1.initalized
     * static Beetle x2.initalized
     * Bettle Constructor
     * i = 9, j = 0
     * Beetle.k initalized
     * k = 47
     * j = 39
     * 
     */
}

 构造器中方法调用初始化特点及原则

package ploymorphism;

class Glyph {
    void draw() {
        System.out.println("Glyph.draw()");
    }

    Glyph() {//1-0-0
        System.out.println("Glyph() before draw()");//2
        draw();//3
        System.out.println("Glyph() after draw()");//5
    }
}

class RoundGlyph extends Glyph {
    private int radius = 1;//6

    RoundGlyph(int r) {//1-0
        radius = r;//7
        System.out.println("RoundGlyph.RoundGlyph(), radius = " + radius);//8
    }

    void draw() {//3-0
        System.out.println("RoundGlyph.draw(), radius = " + radius);//4
    }
}

public class PolyConstructors {
    public static void main(String[] args) {
        new RoundGlyph(5); //1
    }
}

/*
 * 1) 在其它任何事物发生前，将分配给对象的存储空间初始化成二进制的零
 * 2) 调用基类构造器。如上例，调用被覆盖后的draw()方法(要在调用RoundGlyph构造器之前调用)，
 *    由于步骤1的缘故，我们此时发现radius的值为0
 * 3) 按照声明的顺序调用成员的初始化方法
 * 4) 调用导出类的构造器的主题。
 * 
 */
/*
 * 编写构造器的准则
 * 
 * 用尽可能简单的方法使对象进入状态；
 * 如果可以的话，尽量避免调用其它方法；
 * 在构造器内唯一安全能够调用的方法是基类中的final（private也自动是final）方法；
 * 应该朝着上述的方向努力。
 * 
 */
 

 

Java中的堆栈实现，用到内部类

class LinkedStack<T> {
    /*
     * 内部类模拟堆栈，Node<U>也是泛型，它拥有自己的类型参数
     */
    private static class Node<U> {
        U item;
        Node<U> next;

        Node() {
            item = null;
            next = null;
        }

        Node(U item, Node<U> next) {
            this.item = item;
            this.next = next;
        }

        boolean end() {
            return item == null && next == null;
        }
    }

    private Node<T> top = new Node<T>();

    public void push(T item) {
        top = new Node<T>(item, top);
    }

    public T pop() {
        T result = top.item;
        if (!top.end()) {
            top = top.next;
        }
        return result;
    }

    public static void main(String[] args) {
        LinkedStack<String> lss = new LinkedStack<String>();
        for (String s : "Phaser on stun!".split(" ")) {
            lss.push(s);
        }
        String s;
        while ((s = lss.pop()) != null) {
            System.out.println(s);
        }
    }
}

 

Java能不能实例化访问私有方法？

1  该问题要分情况的，如果在类定义中实例化该对象，则可以通过引用访问该对象的所有内容。

2  如果是在类的定义外实例化，则只可以访问非私有的属性。

java父类的构造器私有了， 怎么继承？

private只能本类中使用，其他的都用不了，所以也不能继承。
不过可以通过曲线救国
在父类里提供一个方法，该方法返回父类的对象，然后子类这时可以通过继承方法获取父类的对象。
一般构造器私有比较常用的就是单态了（工具类有的也这样用或者其他）

Java考题练习，继承、访问权限、多态、初始化

class Test {
    private int day;

    private Test(int d) {
        day = d;
    }

    private void print() {
        System.out.println("I am in Test");
    }
}

class DemoTest extends Test {
    private DemoTest() {
        super(2);
    }

    public void print() {
        System.out.println("I am in DemoTest");
    }

    public static void main(String[] args) {
        DemoTest test = new DemoTest();
        test.print();
    }
}

/*
   编译不通过，父类构造器私有，不能继承。把Test的private去掉即可
   多态在这里没有发生，子类不能够覆盖父类的私有方法
*/

 文件Parcel2还有内部类，编译后是如下的三个class文件

StringBuffer的作用以及赋值修改
观察下面的代码

package sunjava;

public class Foo {
    static void operate(StringBuffer a, StringBuffer b){
        a.append(b);
        b = a;
    }
    public static void main(String[] args){
        StringBuffer a = new StringBuffer("A");
        StringBuffer b = new StringBuffer("B");
        operate(a, b);
        System.out.println(a + "," + b);
    }
/*
 * append 函数的作用改变a的值，但是b = a 不能够改变b的值
 * 
 * outPut:
 * AB,B
 * 
 */
}

 和下面的代码对比，会得出更加直观的效果。

package sunjava;

public class No6 {
   public static void stringReplace(String textString){
       textString = textString.replace("j", "i"); //testString 新赋值了一个，与原来的无关
   }
   public static void bufferReplace(StringBuffer textBuffer){
       textBuffer.append("C"); //textBuffer在原来的上面加了一个C,源字符串被修改
   }
   
   public static void main(String[] args){
       String textString = new String("java");
       StringBuffer textBuffer = new StringBuffer("java");
       stringReplace(textString);
       bufferReplace(textBuffer);
       
       System.out.println(textString + textBuffer);
   }
   /*
    * 注意StringBuffer类和String之间的区别
    * 
    * outputs：
    * 
    * javajavaC
    */
}

 

•  注意Overrride和Overload之间的不同点
• Java 内部类 分四种：成员内部类、局部内部类、静态内部类和匿名内部类。
• java成员变量的初始化顺序