java方法和类的使用权限??????

Question

5.不同的包之间类(继承)调用时public,protected方法被访问我想是错的吧。

Answer 1

请参看《Thinking In Java 》第二版 第 25 页 。 这个已经讲得很清楚了，为什么会引出你的这么复杂的理解。

Answer 2

再说你的分类方法是错误的。你应该从public private protected friendly 这四个方面考虑问题，这样情况就少多了

Answer 3

private 只有自己能使
protected  自己和同包 子类可以使
friendly 自己和同包可以使

Answer 4

前面那个不知道你说的是什么意思，把包包含进来应该是import，而不是package;
后面那个问题帮你解释一下吧：
public void paint(Graphics g)
只是awt组件的一个在面板上绘图的方法，是系统自己调用的，至于那个Craphics是一个类
他抛出的是你所在面部上绘图的上下文环境，如果你要在swing上绘图，就用
public void paintComponent(Graphics g)
这个也是系统自动调用的一个方法，我所说的面板是指的Frame, Panel,这些，请注意区分，
因为只有在面部上才能够画图。

Answer 5

/*
 * @(#) Test.java
 * Created on 2004-10-8
 * By James Fancy
 * 
 * private 修饰的内容只有某个类自己可以访问，这个访问甚至可以跨跃对象(当然是这个
 * 类的对象了)，如下面的 copy 方法中，对 privateInt 的赋值就属于这种情况。
 */package jamesfancy;import jamesfancy.test.TestSub;/**
 * Test
 * @author James
 */
public class Test {    private int privateInt;
    private String name;
    private boolean isOk;
    private Object value;    /*
     * “包”级别的构造方法，只有在同一个包中类可以调用。
     * 参阅 jamesfancy.test.TestSub 类中的注释
     */
    Test() {
    }    /*
     * 这里使用了 private 的属性，因为是在同一个类中
     */
    public void copy(Test t) {
        privateInt = t.privateInt;
        name = t.name;
        isOk = t.isOk;
        value = t.value;
    }    public Test(int privateInt, String name, boolean isOk, Object value) {
        this.privateInt = privateInt;
        this.name = name;
        this.isOk = isOk;
        this.value = value;
    }    /*
     * “包”级别的方法
     */
    String toStringPackage() {
        return toString();
    }    /*
     * protected 方法
     */
    protected String toStringProtected() {
        return toString();
    }    /*
     * private 方法
     */
    private String toStringPrivate() {
        return toString();
    }    public String toString() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("PInt[");
        buffer.append(privateInt);
        buffer.append("]; Name[");
        buffer.append(name);
        buffer.append("]; IsOk[");
        buffer.append(isOk);
        buffer.append("]; Value[");
        buffer.append(value);
        buffer.append("]");
        return buffer.toString();
    }    public static void main(String[] args) {
        TestSub test = new TestSub(13, "Test", true, "only a test");
        System.out.println(test.toStringProtected());
        Test t = new Test();
        System.out.println(t.toString());
        t.copy(test);
        /*
         * 这里可以调用 Test 的 private 方法，因为 main 方法也是 Test 的方法之一，
         * 因为这属于同一个类中的调用。
         * 但是，不推荐这样做，我们应该尽可能的把 main 方法看作是一个独立于各个
         * 类的方法。
         */
        System.out.println(t.toStringPrivate());
        SubTest t2 = new SubTest();
        System.out.println(t2.toString());
        System.out.println(t2.toStringX());
    }}/*
 * @(#) Test.java
 * package jamesfancy
 * 注：因和 Test 写在同一文件中，故不需要重复作 package 申明
 *//*
 * 注意，这不是 Test 的子类，但它可以调用 protected 方法 
 */class SubTest {    Test test = new Test(10, "SubTest", false, "In Same Package");    /*
     * 同一包中的类可以调用“包”级别的成员
     */
    public String toString() {
        return test.toStringPackage();
    }    /*
     * 同一包中的类也可以调用 protected 的成员，而不管它是不是这个类的子类
     */
    public String toStringX() {
        return test.toStringProtected();
    }}/*
 * @(#) TestSub.java
 * Created on 2004-10-24
 * By James Fancy
 * 注：这是另一个包中的另一个 java 文件。
 */
package jamesfancy.test;
import jamesfancy.Test;/**
 * TestSub
 * @author James
 */
public class TestSub extends Test {
    
    private String name = "TestSub";
    
    public TestSub(int privateInt, String name, boolean isOk, Object value) {
        /*
         * 这样调用父类构造是不行的，因为在 jamesfancy.Test 中 Test() 这个构造
         * 方法没有加任何修饰符，也就是说，它是属于“包”级别的，只允许同一个包
         * 中的类进行访问
         */
        // super();
        super(privateInt, name, isOk, value);
    }
    
    /*
     * 这个方法不能定义为 toString，因为它调用了 toStringProtected()，而在父类的
     * 定义中，toStringProtected() 会调用 toString()，这样就会引起无限递归调用
     * 
     * 通过 super 调用父类方法的原则：只调用父类的同名方法，否则就有可能引起无限
     * 递归调用。
     */
    public String toStringProtected() {
        /*
         * 同构造方法的原理一样，因为不同包，不能调用“包”级别的方法，所以不能
         * 调用 toStringPackage() 方法
         */
        //return super.toStringPackage();
        
        /*
         * 对于 Test 的 private 方法，就更不能调用了，因为 private 方法只能在类
         * 自身中调用
         */
        //return super.toStringPrivate();
        return super.toStringProtected();
    }
    
    public String toString() {
        /*
         * 下面这句话会不成功，因为 value 在父类中是定义为 private 的
         */
        //return value;        
        return super.toString();
    }}
/*
 * Graphics g，这里 g 是一个参数，是从别的地方传进来的，不需要在访求内部进行实例
 * 化——当然，一般情况下它是在外部实例化完成了之后再传进来的。有时候，也需要在
 * 方法内部检查一个参数是否为 null 来进行一些处理
 * 
 * g.setColor() 用于设置这个 Graphcis 的颜色。Graphics 是绘图对象，是一个“画布”
 * 概念的东西，比如我们要在一个组件中画什么东西，实际上都是画在 Grahics 中的。
 * 
 * size() 返回的是一个 Dimension 对象，这个对象有 height 属性，所以可以简化的写
 * 为 size().height，它实际上等同于下面的语句
 * Dimension d = size();
 * d.height;
 */
 */