一.继承
1.定义
是类与类之间的关系：子类和父类。继承的本质是对某一批类的抽象。
在子类中使用extends关键字，意为扩展，子类是父类的扩展，子类可以继承父类的所有属性和方法（如果属性定义为private，要写成封装（get、set）方法来给子类调用）
Java中只有单继承，因为一个儿子只能有一个父，而父可以有多个儿子。
final定义的类是没有子类的，无法被继承。
2.继承的程序写法
1）先创建一个Person类
//父类
public class Person {
}再创建一个Student子类，因为Student属于Person
//Student是Person，也就是Student是Person的子类，或者叫派生类
public class Student extends Person{
}这样就完成了Student子类对Person父类的继承
2）子类可以继承父类的所有方法，Student类里什么都不写，在Person类中写了如下属性和方法
//父类
public class Person {
public int money=10_0000_0000;
public void say(){
System.out.println("说了一句话");
}
}在Application中调用这些属性和方法，可以正常调用
import com.rzd.oop.demo06.Student;
public class Application {
public static void main(String[] args) {
Student student = new Student();
System.out.println(student.money);
student.say();
}
}但是由于属性一般写成私有的，于是就在Person内写成封装
//父类
public class Person {
private int money=10_0000_0000;
public void say(){
System.out.println("说了一句话");
}
public int getMoney() {
return money;
}
}import com.rzd.oop.demo06.Student;
public class Application {
public static void main(String[] args) {
Student student = new Student();
System.out.println(student.getMoney());
student.say();
}
}3）Super()
super关键字用来调用父类的属性或方法。
创建一个父类Person类，子类Student类，编写程序如下
package com.rzd.oop.demo07;
//父类
public class Person {
protected String name="父name";
public void print(){
System.out.println("Person");
}
}在子类中定义与父类相同的属性名和方法名
package com.rzd.oop.demo07;
//super()
public class Student extends Person{
String name="子name";
public void print(){
System.out.println("Student");
}
//子类调用父类的属性
public void test(String name){
//这个name是当前方法的形参，值是调用这个方法传进来的参数
System.out.println(name);
//this.name表示当前这个类的属性name
System.out.println(this.name);
//super.name表示父类的属性name
System.out.println(super.name);
}
//子类调用父类的方法
public void test1(){
print(); //一般不用这个写法，会分不清。指当前类的print方法，可以按住Ctrl点击它来看跳转到具体哪一个方法
this.print(); //当前类的print方法
super.print(); //父类的print方法
}
}在main方法中调用，可以看到，this指代当前类，super指代父类
package com.rzd.oop;
import com.rzd.oop.demo07.Student;
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.test("实参name");
student.test1();
}
}在子类的构造器中，第一行有一行super();是隐藏代码，就像没有定义构造器时，程序有一个隐藏的无参构造器一样，是默认存在的。
可以通过debug看到，程序走到子类的构造器之后，下一步是走到父类的构造器，说明子类里有颐一句调用父类构造器的语句，也就是super()。
public class Person {
protected String name="父name";
public Person() {
System.out.println("父类的无参构造执行了");
}
}public class Student extends Person {
//Student的无参构造器
public Student() {
//这里有一句隐藏代码，就像没有定义构造器时，程序有一个隐藏的无参构造器一样。
//super(); //调用父类的无参构造器
System.out.println("子类的无参构造执行了");
}
}这时在main方法中new一个Student时，执行结果如下
由此可见，在子类的无参构造的第一行是有一句super();的。
super也可以用来调用构造器
package com.rzd.no02oop.demo06;
public class Person {
int age;
String name;
//定义了有参，无参必须写上
public Person(){
}
public Person(int age, String name) {
this.age = age;
this.name = name;
}
}
package com.rzd.no02oop.demo06;
public class Student extends Person{
int score;
public Student(){
}
//定义一个3个参数的有参构造器，其中两个参数是从父类继承的
public Student(int age,String name,int score){
/* //age和name是直接从父类继承的属性，可以直接用
this.age=age;
this.name=name;*/
/*//也可以直接调用父类的age和name
super.age=age;
super.name=name;*/
//最常用的写法是，在父类定义两个属性的有参构造，子类直接调用父类的有参构造
super(age,name);
this.score=score;
}
}
一些报错的解释：
1.Call to 'super()' must be first statement in constructor body
在子类中调用构造器时，无论是调用本身的构造器，还是调用父类的构造器，都必须写在构造器的第一行。
原因是：this()和super()都是构造方法，作用是在JVM堆中构建出一个对象。如果不写在第一行，例如第一行System.out.println(name);用来输出父类的name属性值，但是此时name对象还没有进行初始化
所以为了避免操作对象时对象还未构建成功，需要this()和super()的调用在第一行实现【以此来创建对象】，防止异常
2.Call to 'this()' must be first statement in constructor body
在子类中调用构造器时，super()和this()不能同时出现。
原因是：this()和super()都是构造方法，作用是在JVM堆中构建出一个对象。super()会调用父类的无参构造器，初始化父类；而this()默认会先调用父类的无参构造器，这样就会对父类进行两次初始化，重复创建两次对象
所以为了避免多次创建对象，同一个方法内只能调用一次this()或super()。
那么同理，也不能既调用父类的无参构造，又调用父类的有参构造了，也会造成重复创建对象。
3.There is no default constructor available in 'com.rzd.oop.demo08.Person'：在Person中没有默认的构造器
如果在父类Person中只提供了有参构造，没有写无参构造，那么此时无参构造自动失效。此时如果在子类Student中调用
在类中，如果只定义了有参构造，那么无参构造自动失效。而在上面这个程序中，子类写了一个无参构造，第一行默认是super();没有写出来，意思为调用父类的无参构造，但是现在父类里并没有无参构造，所以会报错。
所以有两种解决办法
解决方法1：在父类中添加无参构造
解决方法2：在子类中指明要调用的是父类的有参构造
小结：
super()：
1）super()只能用在子类的构造方法中，且必须在第一行
2）所有构造器中，如果没有显式使用super()调用父类的构造器（无论是有参还是无参），则系统就会自动分配super();
2）在子类的普通方法中可以调用super.属性，super.方法等
3）super()和this()不能同时调用，会导致重复创建对象
this()：表示本身类的构造方法
二、方法重写
1.概念
1）只有方法可以重写，和属性无关
2）子类重写父类的方法：方法名、参数列表必须相同，只有方法体可以不同（否则会变成重载）
3）子类的修饰符可以扩大，但不能缩小：public>protected>default<private
4）子类抛出的异常范围可以缩小但不能扩大：ClassNotFoundException<Exception
添加一个Father父类，写一个test方法
//重写都是方法的重写。
public class Father {
public void test(){
System.out.println("父类的test()");
}
}再添加一个Son方法，写一个和父类只有方法体不同的test方法
public class Son extends Father{
public void test(){
System.out.println("子类的test()");
}
}在main方法中初始化
public class Application {
public static void main(String[] args) {
Son son = new Son();
Father father = new Son();//子类重写了父类的方法
son.test();
father.test();
}
}运行结果为
这里就是方法的重写，会去调用子类test方法。
重写的意义：父类的功能对子类来说太多或不够用。
重写的快捷键：Alt+Insert override（重写）、Ctrl+o
快捷添加重写会自动添加代码：
public class Son extends Father{
@Override //注释
public void test() {
super.test();
}
}然后可以修改方法体。
三、权限修饰符
1.default
在同一包内可见，缺省即为default属性。使用对象：类、接口、变量、方法。
public class Demo01 {
public static void main(String[] args) {
String str1="default"; //默认的就是声明为public static final
}
boolean add() { //add（）方法默认为public
return true;
}
}2.private
在同一类内可见。使用对象：变量、方法（类和接口不能用）。 注意：不能修饰类（外部类）
package com.rzd.no02oop.demo05;
public class A {
private int age;
private void eat() {
System.out.println(age);
age = 10;
}
public void setAge(int age) {
this.age = age;
}
}package com.rzd.no02oop.demo05;
public class Test {
public static void main(String[] args) {
A a = new A();
//a.age=100; //私有属性，在另一个类中无法使用
//a.eat(); //私有方法同理
a.setAge(100); //在A中写了get、set方法后可以使用
}
}3.protected
对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
package com.rzd.no02oop.demo05;
public class B {
protected int age;
int num;
public void eat() {
System.out.println(age);
age = 10;
}
}
package com.rzd.no02oop.demo04;
import com.rzd.no02oop.demo05.B;
public class Test1 extends B {
public void test1(){
System.out.println(age); //protected不同包，子类也可以直接访问
//System.out.println(num); //default修饰，则不同包的子类不能访问，但是同一个包下的子类可以访问
}
}
4.public
对所有类可见。使用对象：类、接口、变量、方法
一般，我们属性使用private修饰，方法使用public修饰
扫一扫
799
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
