Java面向对象 08 继承

  继承:

  1. 通过基础可以有效的组织程序结构,明确类之间的关系,充分利用有的类来创建新类,已完成更复杂的设计与开发,

              提高代码的复用性。

  • 概念:1. 当一个类拥有另一个类的数据和操作时,就称这两个类之间具有继承关系。

                     2. 一个父类可以同时拥有多个子类,父类是所有子类的公共成员变量和公共方法的集合,

                         而子类是父类的特殊化,可对公共成员变量和方法在功能内涵方面加以扩展和延伸。

   关于继承和继承的概念:1. 单继承是指任何类都只有一个父类

                                          2. 多继承是指一个类可以有一个以上父类 (单继承,没有多继承!)

                        java中继承是通过exterds关键字来实现的

                         class 子类名 extends父类名

           1. 如果子类和父类在同一个包中,它可以从父类那里继承所有private的成员变量和方法作为自己的成员。

           2. 如果子类和父类不再同一个包中,它可以从父类那里继承protected,public的成员变量和方法

               作为的自己成员。

   继承的本质是对某一批类的抽象,从而实现对现实世界更好的建模。

  • extant的意思是"扩展"。子类是父类的扩展。

  • 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖,组合,聚合等。

  • 继承关系的两个类,一个为子类(派生类)一个为父类(基类)。

  • 子类和父类之间,从意义上讲应该具有“is a”的关系。

  • object类

  • super

  • 方法重写

package src1;
//学生 is 人 :派生类或者子类
//子类继承了父类,拥有父类的全部方法
public class Student2 extends Person
{

private String name="riping";
public void print()
{
 System.out.println("student");
}
public void test1()
  {
print();
this.print();
super.print();
 
}
public void test2(String name)
  {
}
public void test(String name)
{
    System.out.println(name);//jw
    System.out.println(this.name);//riping
    System.out.println(super.name);//jingwen
}
}
  Student2 student2=new Student2();
  student2.say();
  System.out.println(student2.getMoney());
  }
}

 -------------------------------------

class Student
{  
int stu_id;
void set_id(int id)
{
stu_id=id;   //定义方法:设置学号
}
void show_id()  //定义方法:显示学号
{
     System.out.println("the student ID is:"+stu_id);
}
}
class UniversityStudent extends Student
{ //定义子类
int dep_number; //定义子类特有的属性变量
void set_dep(int dep_num)  //定义子类特有的方法
{
dep_number=dep_num;
}  
void show_dep( )
{
System.out.println("the dep_number is:"+ dep_number);
}
public static void main(String args[])
{
    UniversityStudent Lee=new UniversityStudent();
    Lee.set_id(2007070130);  //继承父类学生的属性和方法
    Lee.set_dep(701); //使用本类的属性和方法
    Lee.show_id(); //继承父类学生的方法
    Lee.show_dep(); //使用本类的方法
}
}
​----------------------------
class Vehicle
{
double speed;
String kind;
String color;
void setspeed(double  speed)
{
this.speed=speed;
}
void setkind(String kind)
{
this.kind=kind;
}
void setcolor(String color)
{
this.color=color;
}
double getspeed()
{
return speed;
}
String getnkind()
{
return kind;
}
String getcolor()
{
return color;
}
}
class Car extends Vehicle
{
int passenger;
void setpassenger(int passenger)
{
this.passenger=passenger;
}
int getpassenger()
{
return passenger;
}
}
public class CarTest
{
public static void main (String[] args)
{
Car audi=new Car();
audi.setspeed(140);
audi.setkind("Q7");
audi.setcolor("Red");
audi.setpassenger(5);
System.out.println("audi:");
System.out.println ("kind:"+audi.getnkind());
System.out.println ("speed:"+audi.getspeed());
System.out.println ("color:"+audi.getcolor()());
System.out.println ("passenger:"+audi.getpassenger());

}
}

 

  • 成员变量的隐藏和方法的覆盖:

                   隐藏:子类重新定义一个从父类那里继承的成员变量完全相同的变量,称为成员变量的隐藏。

            方法覆盖:是指子类重定义从父类继承来的一个同名方法,此时子类将清除父类方法的影响。

                   注意:子类在重新定义父类已有的方法时,应保持与父类完全相同的方法头声明,即应与父类有

                              完全相同的方法名,相同的参数表和相同的返回类型。

                 子类通过成员变量的隐藏和方法的重写可以把父类的状态和行为改为自身的状态和行为。

class SuperClass
{
   int x;
   void  setX(){
       x=0;
  }
}
class SubClass extends SuperClass
{
   int x;
   void setX()
  {
        x=5;
  }

}
public class A
{
   public static void main (String[] args)
  {
       SubClass sc=new SubClass();
       sc.setX();
       System.out.print("x="+sc.x);//x=5
  }
}
/*
子类SubClass中声明一个和父类SuperlClass同名的变量x,
并定义了与之相同的方法setX,这时在子类SubClass中父类的成员变量x被隐藏,
父类的方法setX被重写,于是子类对象所使用的变量x为子类中定义的x,
子类对象调用的方法setX也是子类中所实现的方法。
子类通过成员变量的隐藏和方法的重写可以把父类的状态和行为改变为自身的状态和行为。

*/

  • super:1.子类对父类的同名成员变量和方法,分别实行隐藏和覆盖后,但是,有时要在子类中

                     访问父类的变量,父类的方法,java提供的super就可以实现访问。

                  2. 与this类似,this是对当前对象的引用,而super则是对当前对象的父类的引用。

         使用三种情况:1. 访问被隐藏的父类成员变量 (super. VariableName)

                                  2. 调用父类中被覆盖的方法 (super.MethodName)

                                  3.调用父类中的构造方法 (super([paramlist]) )

      super的注意点: 1.super调用父类的构造方法,必须在构造方法的第一个

                                 2.super必须只能出现在子类的方法或者构造方法中!

                                 3. super和this不能同时调用构造方法!

        代表的对象不同:1. this:本身调用者这个对象

                                     2. super:代表父类对象的应用

             前提:1.this:没有继承也可以使用

                       2. super:只能在继承条件才可以用

//Person人
// 在Java中,所有的类,都默认直接或者间接继承object
public class Person
{
   public Person()
  {
       System.out.println("person无参执行了");
  }
   public Student2()
  {
       //隐藏代码:调用了父类的无参构造: super();必须在子类构造器的第一行
       System.out.println("student2无参执行了");
  }
    Student2 student2=new Student2();
​-------------------------------
class SuperClass
{
   int x;
   SuperClass()
  {
       x=3;
       System.out.println("int SuperClass:x="+x);
  }
   void doSomething()
  {
       System.out.println("in superClass.doSomething()");
  }
}
class subclass extends SuperClass
{
   int x;
   subclass()
  {
       super();//调用父类的构造方法
       x=5;
       System.out.println("in subclass : x = "+x);
  }
   void doSomething( )
  {
       super.doSomething( ); //调用父类的方法
       System.out.println("in subClass.doSomething()");
       System.out.println("super.x = "+super.x+" sub.x = "+x);
  }
}
public class T6_4
{
   public static void main(String args[])
  {
       subclass subC = new subclass();
       subC.doSomething();
       /*
       int SuperClass:x=3
       in subclass : x = 5
       in superClass.doSomething()
       in subClass.doSomething()
       super.x = 3 sub.x = 5
        */
  }
}

 

           方法的重写

  • 需要有继承关系,子类重写父类的方法!

       1.方法名必须相同。

       2.参数列表必须相同

       3.修饰符:范围可以扩大但不能缩小:public>protected>default>private

       4.抛出的溢出:范围,可已被缩小,但不能扩大:classNotFoundException ----->Exception(大)

            重写,子类的方法和父类必要一致:方法体不同!

    为什么需要重写:

     1.父类的功能,子类不一定需要,或者不一定满足!

                   快捷键 Alt+Insert :override;

//重写都是方法的重写,和属性无关
class B
{
   public void test()
  {
       System.out.println("b=>test()");
  }
}
//继承
class S extends B
{
   //override 重写
   public void test()
  {
       System.out.println("a=>test()");
  }
}
class A
{
   public static void main(String[] args)
{
       //方法的调用只和左边,定义的数据类型有关
       //静态方法和非静态方法的方法区别很大!
       //静态方法:方法的调用只和左边,定义的类型有关
       //非静态:重写
       S s = new S();//S
       s.test();
       //父类的引用指向了子类
       // B b=new A();//子类重写了父类的方法
       // b.test();//B
       B b = new B();
       b.test();
  }
}
  • 继承设计的原则:1. 尽量将公共属性和操作放在父类中,通过定义父类的方法,使得所有的子类都能够重用

                                           这些代码,对于提高程序的开发效率有很大的好处。

                                       2. 子类继承父类的前提是父类中的方法对子类都是同用的,如果要声明一个类

                                           继承另一个类,就必须考虑父类的方法是否对子类都适用,如果不适用的方法很多,

                                           那么就失去继承的意义。

 

posted @   zjw_rp  阅读(28)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· winform 绘制太阳,地球,月球 运作规律
· AI与.NET技术实操系列(五):向量存储与相似性搜索在 .NET 中的实现
· 超详细:普通电脑也行Windows部署deepseek R1训练数据并当服务器共享给他人
· 【硬核科普】Trae如何「偷看」你的代码?零基础破解AI编程运行原理
· 上周热点回顾(3.3-3.9)
点击右上角即可分享
微信分享提示