参考地址
140
java 中若要在子类调用父类的方法，需使用关键字super。
实例 class Animal{ void go(){ System.out.println("animal go"); } } class Dog extends Animal{ void go(){ //调用父类方法 super.go(); } } //驱动函数 public static void main(String[] args){ Dog dog=new Dog(); dog.go(); }输出结果：
animal gotianqixin 429***967@qq.com 参考地址
#0
我是小菜鸟
824***448@qq.com
183
面向对象编程——继承和多态
//---引用我课堂老师的讲义（詹老师）
1、为什么使用继承
从已有的类派生出新的类，称为继承。
在不同的类中也可能会有共同的特征和动作，可以把这些共同的特征和动作放在一个类中，让其它类共享。
因此可以定义一个通用类，然后将其扩展为其它多个特定类，这些特定类继承通用类中的特征和动作。
继承是 Java 中实现软件重用的重要手段，避免重复，易于维护，易于理解。
2、父类和子类
如果类 B 从类 A 派生，或者说类 B 扩展自类 A，或者说类 B 继承类 A， 则称类 A 为"父类"，也称为超类、基类；称类 B 为"子类"，也称为次类、扩展类、派生类。
子类从它的父类中继承可访问的数据域和方法，也可以添加新的数据域和新的方法。
定义继承的语法：
修饰符 class 子类名 extends 父类名例如：Shape 类是父类，其子类可以有 Circle 类、Rectangle 类、Triangle 类，等等。
继承的注意点：
子类不是父类的子集，子类一般比父类包含更多的数据域和方法。
父类中的 private 数据域在子类中是不可见的，因此在子类中不能直接使用它们。
继承是为"是一个"的关系建模的，父类和其子类间必须存在"是一个"的关系，否则不能用继承。
但也并不是所有"是一个"的关系都应该用继承。例如，正方形是一个矩形，但不能让 Square 类来继承 Rectangle 类，因为正方形不能从矩形扩展得到任何东西。正确的继承关系是 Square 类继承 Shape 类
Java 只允许单一继承（即一个子类只能有一个直接父类），C++ 可以多继承（即一个子类有多个直接父类）。
3、super 关键字
super 表示使用它的类的父类。super 可用于：
调用父类的构造方法；
调用父类的方法（子类覆盖了父类的方法时）；
访问父类的数据域（可以这样用但没有必要这样用）。
调用父类的构造方法语法：
super(); 或 super(参数列表);注意：super 语句必须是子类构造方法的第一条语句。不能在子类中使用父类构造方法名来调用父类构造方法。 父类的构造方法不被子类继承。调用父类的构造方法的唯一途径是使用 super 关键字，如果子类中没显式调用，则编译器自动将 super(); 作为子类构造方法的第一条语句。这会形成一个构造方法链。
静态方法中不能使用 super 关键字。
调用父类的方法语法：
super.方法名(参数列表);如果是继承的方法，是没有必要使用 super 来调用，直接即可调用。但如果子类覆盖或重写了父类的方法，则只有使用 super 才能在子类中调用父类中的被重写的方法。
4、this 关键字
this 关键字表示当前对象。可用于：调用当前类的构造方法，并且必须是方法的第一条语句。如：this(); 调用默认构造方法。this(参数); 调用带参构造方法。
限定当前对象的数据域变量。一般用于方法内的局部变量与对象的数据域变量同名的情况。如 this.num = num。this.num 表示当前对象的数据域变量 num，而 num 表示方法中的局部变量。
我是小菜鸟 824***448@qq.com
#0
Mr.先生
yu5***26@163.com
104
final 的作用随着所修饰的类型而不同
1、final 修饰类中的属性或者变量
无论属性是基本类型还是引用类型，final 所起的作用都是变量里面存放的"值"不能变。
这个值，对于基本类型来说，变量里面放的就是实实在在的值，如 1，"abc" 等。
而引用类型变量里面放的是个地址，所以用 final 修饰引用类型变量指的是它里面的地址不能变，并不是说这个地址所指向的对象或数组的内容不可以变，这个一定要注意。
例如：类中有一个属性是 final Person p=new Person("name"); 那么你不能对 p 进行重新赋值，但是可以改变 p 里面属性的值 p.setName('newName');
final 修饰属性，声明变量时可以不赋值，而且一旦赋值就不能被修改了。对 final 属性可以在三个地方赋值：声明时、初始化块中、构造方法中，总之一定要赋值。
2、final修饰类中的方法
作用：可以被继承，但继承后不能被重写。
3、final修饰类
作用：类不可以被继承。
Mr.先生 yu5***26@163.com
#0
WaterHole
710***626@qq.com
85
java文件被编译成class文件时，在子类的所有构造函数中的第一行（第一个语句）会默认自动添加 super() 语句，在执行子类的构造函数前，总是会先执行父类中的构造函数。
在编写代码要注意：
1.如果父类中不含 默认构造函数（就是 类名() ），那么子类中的super()语句就会执行失败，系统就会报错。一般 默认构造函数 编译时会自动添加，但如果类中已经有一个构造函数时，就不会添加。
2.执行父类构造函数的语句只能放在函数内语句的首句，不然会报错。
在继承关系中，在调用函数（方法）或者类中的成员变量时，JVM（JAVA虚拟机）会先检测当前的类（也就是子类）是否含有该函数或者成员变量，如果有，就执行子类中的，如果没有才会执行父类中的。如下：
public class Start { public static void main(String[] args) { Cat cat=new Cat("Jack","黑色"); cat.eat(); cat.run(); cat.sleep(); } } class Animal { String name; public Animal(){}//必须要写这个构造函数，不然Cat类的代码会出错 public Animal(String name) { this.name=name; } void eat() { System.out.println(name+"正在吃"); } void run() { System.out.println(name+"正在奔跑"); } void sleep() { System.out.println(name+"正在睡觉"); } } class Cat extends Animal { String color; public Cat(String name,String color) { this.name=name; this.color=color; } void eat() { System.out.println(color+"的"+name+"正在吃鱼"); } }运行结果如下：
黑色的Jack正在吃鱼 Jack正在奔跑 Jack正在睡觉当子类出现与父类一样的函数时，这个被称为 重写 也叫 覆盖
Object类是所有类的直接父类或间接父类，也就是说是所有类的根父类，这个可以运用于参数的传递
如下：
public class Start { public static void main(String[] args) { A a=new A(); B b=new B(); C c=new C(); D d=new D(); speak(a); speak(b); speak(c); speak(d); } // instanceof 关键字是用于比较类与类是否相同，相同返回true，不同返回false //当你不清楚你需要的参数是什么类型的，可以用Object来代替，Object可以代替任何类 static void speak(Object obj) { if(obj instanceof A)//意思是：如果参数是 A 类，那么就执行一下语句 { A aobj=(A)obj;//这里是向下转换，需要强制转换 aobj.axx(); } else if(obj instanceof B) { B bobj=(B)obj; bobj.bxx(); } else if(obj instanceof C) { C cobj=(C)obj; cobj.cxx(); } } } //这里举了四个类，他们的函数都不同，但都是 Object 类的子类 class A { void axx() { System.out.println("Good morning!"); System.out.println("This is A"); } } class B { void bxx() { System.out.println("Holle!"); System.out.println("This is B"); } } class C { void cxx() { System.out.println("Look!"); System.out.println("This is C"); } } class D { void dxx() { System.out.println("Oh!Bad!"); System.out.println("This is D"); } }运行结果：
Good morning! This is A Holle! This is B Look! This is CWaterHole 710***626@qq.com
#0
wyk123
101***6246@qq.com
73
子类的所有构造方法内部， 第一行会（隐式）自动先调用父类的无参构造函数super()；
如果子类构造方法第一行显式调用了父类构造方法，系统就不再调用无参的super()了。
实例：
class Base { public Base() { System.out.println("Base--默认构造方法"); } public Base(int c){ System.out.println("Base--有参构造方法--" + c); } } public class Derived extends Base { public Derived() { // super(); //系统会自动隐式先调用父类的无参构造函数 super(); //必须是第一行，否则不能编译 System.out.println("Derived--默认构造方法"); } public Derived(int c) { // super(); //系统会自动隐式先调用父类的无参构造函数 super(); //必须是第一行，否则不能编译 System.out.println("Derived--有参构造方法" + c); } public Derived(int a, int b) { super(a); //如果子类构造方法第一行显式调用了父类构造方法，系统就不再调用无参的super()了。 System.out.println("Derived--有参构造方法--" + b); } public static void main(String[] args) { System.out.println("============子类无参============"); Derived no = new Derived(); System.out.println("============子类有参============"); Derived have = new Derived(33); System.out.println("============子类有参============"); Derived have2 = new Derived(33, 55); } }运行结果如下：
============子类无参============ Base--默认构造方法 Derived--默认构造方法 ============子类有参============ Base--默认构造方法 Derived--有参构造方法33 ============子类有参============ Base--有参构造方法--33 Derived--有参构造方法--55注意：如果父类没有无参构造函数，创建子类时，不能编译，除非在构造函数代码体中的第一行显式调用父类有参构造函数。
wyk123 101***6246@qq.com
#0
芳小酱
fan***u.ling@foxmail.com
34
子类不能直接继承父类中的 private 属性和方法。
/**建立一个公共动物父类*/ public class Animal { private String name; private int id; /*由于name和id都是私有的，所以子类不能直接继承， 需要通过有参构造函数进行继承*/ public Animal(String myname,int myid) { name = myname; id = myid; } public void eat() { System.out.println(name+"正在吃"); } public void sleep() { System.out.println(name+"正在睡"); } public void introduction() { System.out.println("大家好！我是" +id+"号"+name +"."); } }子类 Penguin 需要通过关键字 super 进行声明
public class Penguin extends Animal { public Penguin(String myname,int myid) { super(myname,myid); // 声明继承父类中的两个属性 } }具体通过有参构造函数进行继承。
public class PenguinQQ { public static void main(String[] args) { // TODO Auto-generated method stub Penguin QQ = new Penguin("小冰",10086); //调用一个有参构造方法 QQ.eat(); QQ.sleep(); QQ.introduction(); } }运行结果:
小冰正在吃 小冰正在睡 大家好！我是10086号小冰.芳小酱 芳小酱 fan***u.ling@foxmail.com
#0
nanjidifang
322***1300@qq.com
90
Java 转型问题其实并不复杂，只要记住一句话：父类引用指向子类对象。
什么叫父类引用指向子类对象，且听我慢慢道来。
从 2 个名词开始说起：向上转型(upcasting) 、向下转型(downcasting)。
举个例子：有2个类，Father 是父类，Son 类继承自 Father。
Father f1 = new Son(); // 这就叫 upcasting （向上转型) // 现在 f1 引用指向一个Son对象 Son s1 = (Son)f1; // 这就叫 downcasting (向下转型) // 现在f1 还是指向 Son对象第2个例子：
Father f2 = new Father(); Son s2 = (Son)f2; // 出错，子类引用不能指向父类对象你或许会问，第1个例子中：Son s1 = (Son)f1; 为什么是正确的呢。
很简单因为 f1 指向一个子类对象，Father f1 = new Son(); 子类 s1 引用当然可以指向子类对象了。
而 f2 被传给了一个 Father 对象，Father f2 = new Father(); 子类 s1 引用不能指向父类对象。
总结：
1、父类引用指向子类对象，而子类引用不能指向父类对象。
2、把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转换吗，如：
Father f1 = new Son();3、把指向子类对象的父类引用赋给子类引用叫向下转型(downcasting)，要强制转换，如：
f1 就是一个指向子类对象的父类引用。把f1赋给子类引用 s1 即 Son s1 = (Son)f1;
其中 f1 前面的(Son)必须加上，进行强制转换。
更多内容请查看：Java 转型问题
nanjidifang 322***1300@qq.com
#0
ToToXie
wdt***@163.com
53
对理解继承来说，最重要的事情是，知道哪些东西被继承了，或者说，子类从父类那里得到了什么。答案是：所有的东西，所有的父类的成员，包括变量和方法，都成为了子类的成员，除了构造方法。构造方法是父类所独有的，因为它们的名字就是类的名字，所以父类的构造方法在子类中不存在。除此之外，子类继承得到了父类所有的成员。
但是得到不等于可以随便使用。每个成员有不同的访问属性，子类继承得到了父类所有的成员，但是不同的访问属性使得子类在使用这些成员时有所不同：有些父类的成员直接成为子类的对外的界面，有些则被深深地隐藏起来，即使子类自己也不能直接访问。下表列出了不同访问属性的父类成员在子类中的访问属性：
父类成员访问属性 在父类中的含义 在子类中的含义public的成员直接成为子类的public的成员，protected的成员也直接成为子类的protected的成员。Java的protected的意思是包内和子类可访问，所以它比缺省的访问属性要宽一些。而对于父类的缺省的未定义访问属性的成员来说，他们是在父类所在的包内可见，如果子类不属于父类的包，那么在子类里面，这些缺省属性的成员和private的成员是一样的：不可见。父类的private的成员在子类里仍然是存在的，只是子类中不能直接访问。我们不可以在子类中重新定义继承得到的成员的访问属性。如果我们试图重新定义一个在父类中已经存在的成员变量，那么我们是在定义一个与父类的成员变量完全无关的变量，在子类中我们可以访问这个定义在子类中的变量，在父类的方法中访问父类的那个。尽管它们同名但是互不影响。
在构造一个子类的对象时，父类的构造方法也是会被调用的，而且父类的构造方法在子类的构造方法之前被调用。在程序运行过程中，子类对象的一部分空间存放的是父类对象。因为子类从父类得到继承，在子类对象初始化过程中可能会使用到父类的成员。所以父类的空间正是要先被初始化的，然后子类的空间才得到初始化。在这个过程中，如果父类的构造方法需要参数，如何传递参数就很重要了。
ToToXie wdt***@163.com
#0
战神阿伦第一
116***6050@qq.com
45
构造器下面的，初学者可能迷惑的地方：
输出结果为：
SuperClass(int n) SubClass SuperClass() SubClass(int n):200首先读一波程序，从主类下的主函数开始，对子类分别实例化了两个对象，sc 对象未赋值，sc2 赋值为 200。
然后从上到下读一波程序，一个SuperClass父类下有一个成员变量，两个构造函数（一个不带参，一个带参）；接下来是一个SubClass子类，子类继承父类，有一个成员变量，但要注意的是父类中的成员变量是私有的，所以子类中的私有成员变量并不是从父类继承过来的，而是重写了一遍。两个构造函数（一个不带参，一个带参）；
理解 this 和 super，this 指的是引用当前对象下东西，super 则是引用当前对象的父类。
第一个输出：SubClass 类实例化对象 sc 未赋值，故访问 SubClass 类下的第一个无参构造函数，super(300) 的含义是访问父类中的有参构造函数，故打印输出 SuperClass(int n)
第二个输出：还是接着第一个输出后面，程序继续往下执行，打印输出 SubClass，这就是第二个输出结果，此时对象 sc 结束对 SubClass 类下的第一个无参构造函数的访问
第三个输出：SubClass 类实例化对象 sc 赋值为 200，故访问 SubClass 类下的第二个有参构造函数，子类构造函数中第一条语句如未写带参或不带参的super()，则默认为 super()，所以访问父类中的无参构造函数，故打印输出 SuperClass()
第四个输出：还是接着第三个输出后，程序继续往下执行，由于传递给子类下的有参构造函数 int n=200，所以打印输出 SubClass(int n):200。
战神阿伦第一 116***6050@qq.com
#0
FS
429***f0967@qq.com
295
FS 429***f0967@qq.com
#0
Geyj
181***6857@qq.com
参考地址
17
关于成员内部类的继承问题。一般来说，内部类是很少用来作为继承用的。但是当用来继承的话，要注意两点：
1）成员内部类的引用方式必须为 Outter.Inner。
2）构造器中必须有指向外部类对象的引用，并通过这个引用调用super()。这段代码摘自《Java编程思想》
class WithInner { class Inner{ } } class InheritInner extends WithInner.Inner { // InheritInner() 是不能通过编译的，一定要加上形参 InheritInner(WithInner wi) { wi.super(); //必须有这句调用 } public static void main(String[] args) { WithInner wi = new WithInner(); InheritInner obj = new InheritInner(wi); } }Geyj 181***6857@qq.com 参考地址
