子类能不能继承父类的私有成员？就是说子类能不能继承父类的所有成员？？:)

在java的继承中，子类是不能继承父类的私有方法和属性的，父类把属性和方法定义成私有的就是不想让外界访问他的属性和方法，
如果继承了他的私有属性和方法，那定义私有还有什么意义啊？ 所以子类是不能继承父类的属性和方法的。

感觉是继承过来了，但是不能直接访问~

数据隐藏是在类中定义变量时，加上 private 关键字修饰，这时，只能由类中定义的函数来访问类中的数据。例如：私有仅仅是封装的一种表现形式。

1.   public class Date {
   
2.     private int day, month, year;
   
3.   }
   
4.    
   
5.   public class DateUser {
   
6.     public static void main(String args[]) {
   
7.       Date mydate = new MyDate ();
   
8.       mydate.day = 21;  //illegal! (ref:private)
   
9.     }
   
10.   }

复制代码

直接对 day 赋值是错误的。这样做的好处是可以避免将错误的值赋予成员变量，例如：

1. mydate.day = 32; // invalid day

复制代码

如果类的成员变量封装在类中，类的用户只能通过类中的函数来修改成员变量，这样可以事先在函数中加入检查代码，避免错误发生。例如：

1.   public void setDay(int day) {
   
2.   if (day > this.daysInMonth()) {
   
3.       System.err.println("Invalid day" + da);
   
4.   }
   
5.   else
   
6.       this.day = day;
   
7.   }

复制代码

这个方法在对变量赋值前先检验所要设定的日期是否合法。

子类不能继承私有成员，但可以通过另外的非私有成员调用!
例如
class Outer
{
private  int x = 3;
void method()
{
  System.out.println("输出外部类变量："+x);
   }
}
class  jh
{
public static void main(String[] args)
{
  Outer out = new Outer();
  out.method();
  }
}
这样就可以访问私有变量啦，函数同样适用！

子类是可以继承父类的所有成员的，包括private(构造方法除外)，但是不能够直接访问。记得之前看过一个比喻：
父亲有一个盒子，里面放着一个小秘密，可能是和母亲的情书，然而盒子是锁着的，钥匙只有父亲才有。
孩子知道父亲有一个盒子，也知道父亲去世以后盒子和那把钥匙就是自己的了，然而，现在，孩子没有钥匙，也就看不到里面的东西，除非父亲打开盒子给孩子看，或者父亲打开盒子自己把情书念给孩子听。

子类不继承父类私有成员
        父类中私有成员对外不可见，子类对象中无法访问这些成员。
构造函数不被继承
        构造函数通常用来初始化类的成员变量，父类和子类的成员变量不同，初始化方式也不同，构造函数的名字也不同。

子类继承父类所有的成员变量和成员方法，但不继承父类的构造方法。
《java就业培训教程》--128页...额.等高手- -

不能

namespace 对象

{

    class A

    {

        private string aa = "dfdf";

        private string print()

        {

            return "****";

        }



        public string AA

        {

            get { return aa; }



        }

    }



    class B : A

    {

        private int a = 1;

        public void test()

        {

            //Type type = typeof(A);

            //MethodInfo methodInfo = type.GetMethod("print", BindingFlags.NonPublic | BindingFlags.Instance);

            //A testA = (A)Activator.CreateInstance(type, false);

            //string str = (string)methodInfo.Invoke(testA, null);

            //Console.WriteLine(str);



            Type type2 = typeof(B);

            MemberInfo[] memberInfo = type2.GetMembers(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.GetField);

            foreach (MemberInfo mi in memberInfo)

            {

                Console.WriteLine(mi.Name);

            }

        }



        class Program

        {

            static void Main(string[] args)

            {

                B b = new B();

                b.test();

            }

        }

    }



}

http://bbs.itheima.com/forum.php ... =%E7%BB%A7%E6%89%BF好像已有同学讨论过....

张洪慊 发表于 2013-1-25 20:05
class Father
{
        private int num=3;

现在晕了,继承定义到底指什么? 我记得毕老师讲,当创建子类对象时,父类的私有成员也在子类对象中.

class Father
{
        private int num=3;
        public int getNum()
        {
          return num;
        }
}
class Son extends Father
{

}
class ExtendsDemo
{
  public static void main(String[] args)
  {
    Son s=new Son();
        System.out.println(s.getNum());//3
  }

}
如果不能继承?怎么能打印出3.
继承了,但是不能直接访问而已.

首先要明白private修饰符的意思，他表示私有的，意思就是除了本类，别的任何类都不能访问他，也包括子类.
如果你想要子类去访问private的域，那么你只有在父类里面写一个public方法，这个方法的返回值是这个private的域，通过这种转换的方式去访问

私有成员,就是用private修饰的成员变量和成员函数,他们的作用范围是类中,在类以外无法访问,
子类可以访问和继承父类的非私有成员,
如果想要访问私有成员,需要父类提供方法才能访问.也就是说不能直接继承私有成员
class Fu
{
        String name = "父";
        private String name_1= "父1";
        void show()
        {
                System.out.println(name);
        }
        private void show_1()
        {
                System.out.println(name_1);
        }
}

class Zi extends Fu
{
       
}

class TestExtends
{
        public static void main(String[] args)
        {
                Zi z = new Zi();
                z.name = "子";//继承父类的name属性,可以直接访问,
                z.show();//继承父类的show()方法,可以直接访问.
                //z.name_1 = "zi";//无法继承和访问成员变量name_1,
                //z.show_1();//无法继承和访问成员函数show_1();
        }
}

不能。即使子类中有跟父类的私有成员同名的成员那也是子类自己特有的成员，不是继承来的。