Java继承（面向对象编程）

Bertha 。 2022-01-27 08:01 398阅读 0赞

Java面向对象包含的内容很多（面向对象的基本概念，类和对象，继承，接口，嵌套类和匿名类，反射，注解等等）。  
所谓面向对象，就是其程序设计是以对象（Object)类为核心，以对象所拥有的数据状态和功能行为为工具解决特定问题。  
每个对象都拥有两个属性：状态（state）和行为（Behavior）。

#### 继承 ####

Java语法中通过extends关键字实现类的继承机制。  
通过继承，子类自动拥有了基类的所有成员（成员变量和成员方法）。  
Java只支持单继承，不允许多继承。即一个子类只能有一个基类，一个基类可以派生出多个子类。

##### 对象成员的访问权限 #####

<table> 
 <thead> 
  <tr> 
   <th align="center">修饰符</th> 
   <th>类内部</th> 
   <th>同一个包</th> 
   <th>子类</th> 
   <th align="right">任何地方</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">private</td> 
   <td>Yes</td> 
   <td>Yes</td> 
   <td>部分Yes</td> 
   <td align="right"></td> 
  </tr> 
  <tr> 
   <td align="center">default</td> 
   <td>Yes</td> 
   <td>Yes</td> 
   <td>部分Yes</td> 
   <td align="right"></td> 
  </tr> 
  <tr> 
   <td align="center">protected</td> 
   <td>Yes</td> 
   <td></td> 
   <td></td> 
   <td align="right"></td> 
  </tr> 
  <tr> 
   <td align="center">public</td> 
   <td>Yes</td> 
   <td>Yes</td> 
   <td>Yes</td> 
   <td align="right">Yes</td> 
  </tr> 
 </tbody> 
</table>

#### 子类重写父类的方法 ####

1.在子类的基类中可以根据需要对从基类中继承的方法进行重写  
2.重写方法必须和被继承方法具有相同的名称  
3.重写方法不能使用比被重写方法更严格的访问权限

public class T_OverWrite {     //父类
    int age;     
    String name;     
    void setAge(int age) {  this.age = age;  }     
    void setName(String name)  { this.name = name;   }    
    int getAge() {      return age;     }     
    String getName() {      return name;     } 
    public String getInfo() {      return ("我的名字是"+name+"我的年龄："+age);     } }  
    
    
    public class Student extends T_OverWrite {
    String school; 
     void setSchool(String school) {
      this.school = school;
     }
     String getSchool() {
       return school;
     }
     public String getInfo() { //这里就是重写了父类的方法
         return ("我的名字是"+name+"我的年龄："+age+"我的学校是"+school);
      }
      public static void main(String[] args) {
      T_OverWrite person = new T_OverWrite();
      Student student = new Student();
       person.setAge(20);
       person.setName("rong");
       student.setAge(21);
       student.setName("1ing");
       student.setSchool("哈哈");    
       System.out.println(person.getInfo());
       System.out.println(student.getInfo());
       }
       }

###### Static ######

1.在类中声明的static变量是静态成员变量，  
2.它是该类的共有变量，在第一次使用时被初始化。  
3.对于该类的所有成员变量来说，static成员变量只有一份 。  
4.可以通过对象的引用和类名访问该变量

public class T_Static {
     private static int sid=0;
     private String name;
     int id;
     T_Static(String name) {
      this.name = name;
      id = sid++;  
     }
     void print() {
      System.out.println("My name is "+name+"NO."+id);
     }
     public static void main(String[] args) {
        T_Static.sid = 100;//通过类名的调用改变static变量
        T_Static one = new T_Static("小明");
        one.sid = 1000;//通过对象的引用改变static变量
        T_Static two = new T_Static("小华");
        one.print();
        two.print();
     }
    }

###### this ######

1.this可以看成一个对象，它的值是对当前对象的引用  
2.当必须要指出使用方法的对象是要使用this

public class This {
        int i;
        This(int i) {
         this.i = i;
        }
        This add() {
         i++;
         return this;//将i的值返回给当前这个对象
        }
        void print() {
         System.out.println(i);
        }
     public static void main(String[] args) {  
        This rr = new This(100);
        rr.add().add().print();
     }
    }

###### super ######

1.  super关键字的作用其中之一是子类重写父类的方法时，需要保留父类方法的语句时，可以用super语句调用。

public class T_Super {
     public int value;
     public void way() {
      value = 100;
      System.out.println("父类的value："+value);
     }
    }
    
    class _Super extends T_Super {
     public int value;
     public void way() {
      super.way();//调用父类的way
      value = 200;
      System.out.println("子类的value："+value);
      System.out.println("父类的value："+super.value);
     }
     public static void main(String[] args) {
      _Super rr = new _Super();
      rr.way();
     }
    }

1.  子类构造的过程中必须要调用父类的构造方法。
2.  子类可以用super关键字调用父类的构造方法，且super语句必须写在子类构4造方法的第一行。
3.  如果子类中没有显示调用父类的构造方法，则默认调用父类无参数的构造方法
4.  如果子类中没有显示调用父类的构造方法，而且父类中没有无参的构造方法，则编译出错。

public class Superclass {
        private int n;
        Superclass() {
         System.out.println("Superclass()");
        }
        Superclass(int n) {
         System.out.println("Superclass("+n+")");
         this.n= n;
         
        }
    }
    
    public class Subclass extends Superclass {
     private int n;
        Subclass() {
         //super(300);
         System.out.println(" Subclass");
        }
        Subclass(int n) {
         super(300);
         System.out.println("Subclass("+n+")");
        }
     public static void main(String[] args) {
      Subclass su1 = new Subclass();
      Subclass su2 = new Subclass(300); 
     }
    }

##### 对象的引用转型 #####

1 一个基类的引用变量可以”指向“其子类的对象  
2 一个基类的引用变量不能访问子类新增加的成员（属性和方法)  
3 可以使用 引用变量+instanceof+类名 判断该引用型变量所指的对象是否属于该类或该类的子类  
4 子类的对象可以当作基类对象来使用称为上转型，反之则称之为下转型  
以下面小程序为例：

public class Animal {
    public String name;
    Animal(String name) {
     this.name = name;
    }
    }
    
    public class Cat extends Animal {
    public String eyecolor;
     Cat(String name, String c) {
       super(name);
      this.eyecolor = c;  
     }
    }
    
    public class Dog extends Animal {
    public String furcolor;
     Dog(String name, String f) {
       super(name);
      this.furcolor = f;
     }
      public void f(Animal obj) {
      System.out.println("动物的名字:"+obj.name);
      if(obj instanceof Cat) {
         Cat ca = (Cat)obj;
       System.out.println("猫眼的颜色::"+ca.eyecolor);
      }
      }
       public static void main(String[] args) {
        Animal a = new Animal("a");
        Cat c = new Cat("c","blue");
        Dog d = new Dog("d","yellow");
        d.f(c);
        System.out.println(a instanceof Animal);//true
        System.out.println(c instanceof Animal);//true
        System.out.println(d instanceof Animal);//true
        System.out.println(a instanceof Dog); //false  
        Animal animal = new Dog("g","pink");//这里a虽然成了一条狗，但它只看到作为Animal的部分(向上转型）
        System.out.println(animal.name);//只能看到名字
        //System.out.println(a.furcolor);//编译错误
        Dog d1 = (Dog)animal;//要加强制转换符
        System.out.println(d1.furcolor); 
        Cat cat =(Cat)a;//向下转型，编译无错误，运行时出错
        System.out.println(cat.name);
      }