精华内容
下载资源
问答
  • Java继承

    2016-06-27 16:03:15
    Java继承是面向对象的第二个特性,Java只支持单继承防止产生二义性,以免出现同时继承多个类,而类又有相同的方法,JVM一下子不知道要找哪个类的方法了,瞬间蒙蔽,over。继承,首先要有继承,就必须存在关系。...

    Java继承是面向对象的第二个特性,Java只支持单继承,防止产生二义性,以免出现同时继承多个类,而类又有相同的方法,JVM一下子不知道要找哪个类的方法了,瞬间蒙蔽,over。

    继承,首先要有继承,就必须存在关系。比如,父与子的关系。

    继承关系中,父类又称为基类,子类又称为派生类。

    继承,使得子类可以从父类继承父类所拥有的属性和行为,并添加一些属于自己的属性和行为。

    继承的特征:传递性、可重用性、易维护性。

    为什么说具有传递性?

    比如有3个类ABC,A是B的父类,B是C的父类,那么A也算是C的父类(其实是爷爷类),总之就是A中有的属性和行为,C可以继承到。这就是所谓的传递性。

    为什么说具有可重用性?

    一个类中的属性和行为可以被多个子类所使用,不用子类再单独去写啊写啊,一个父类就解决,简单粗暴无冗余,就是所说的可重用性。

    为什么说具有易维护性?

    子类今天想用这个父类,明天想用那个父类,一个extends分分钟解决,不必再删啊删啊,添加啊添加啊。传说中的,Java通过增强程序的一致性来减少模块接口之间的耦合程度来提高维护性。

    展开全文
  • Java继承的特点

    2019-10-26 23:26:54
    Java继承的特点 在java中,继承具有以下特点: 1.只支持单继承,即一个子类只允许有一个父类。 2. 子类可以拥有父类的属性和方法 3. 子类可以拥有自己的属性和方法 4. 子类可以重写覆盖父类的方法 提示:为防止...

    Java中继承的特点

    在java中,继承具有以下特点:

    1.只支持单继承,即一个子类只允许有一个父类。
    2. 子类可以拥有父类的属性和方法
    3. 子类可以拥有自己的属性和方法
    4. 子类可以重写覆盖父类的方法
    提示:为防止子类在想要重写父类方法时写错,造成无法覆盖,我们采用注解@Override,注解是写给编译器的注释,告诉编译器,如果下面的方法没有覆盖父类方法,则给出报错。
    5. 可以声明父类,创建子类(又称父类装载子类)
    例如:Person p=new Teacher();
    (1) 声明什么样的类型,就只能调用什么类型的属性和方法
    (2) 创建什么样的类型,就真正运行的什么类型的方法
    提示:(1)和(2)称为向上转型, 例如:Person p=new Teacher();那么p只能打点调用Person类中的方法和属性(看到的),但实际上却运行的是创建的Teacher类型的方法。
    (3) 创建什么样的类型,就可以强转为什么类型
    提示:例如: Person p=new Teacher();
    Teacher t=(Teacher) p;
    这种叫做向下转型,此时t调用的是创建的Teacher类型的相应属性和方法。
    继承的优点包括:

    1. 提高代码复用性和维护性
    2. 父类的属性方法可以用于子类
    3. 可以轻松的定义子类
    4. 使设计应用程序变得简单

    继承的缺点:
    类的耦合性增强了,削弱了子类的独立性。

    展开全文
  • Java中的继承详解

    万次阅读 2019-10-20 00:52:45
    Java中的继承详解继承的基本知识成员访问与继承构造函数与继承super关键字使用super调用超类构造函数使用super访问超类成员创建多级层次结构怎样调用构造函数超类引用与子类对象方法重写抽象类final关键字Object类 ...

    继承的基本知识

    继承是面向对象程序设计中的三个基本原则1之一。

    在Java语言中,被继承的类被称为超类,继承类被称为子类2

    比如狗类是动物类,牧羊犬类又是狗类。于是我们可以说狗类继承了动物类,而牧羊犬类就继承了狗类。于是狗类就是动物类的子类(或派生类),动物类就是狗类的父类(或基类)。

    实现继承将需要使用extends关键字。

    如下:

    // A simple class hierarchy
    class TwoDShape{
    	double length;
    	double width;
    		
    	void show(){
    		System.out.println("length:" + length + " width:" + width);
    	}
    }
    	
    class Triangle extends TwoDShape{
    	String style;
    	
    	double area(){
    		return length * width;
    	}
    	
    	void showStyle() {
    		System.out.println("style:" + style);
    	}
    }
    
    class Shapes {
    	public static void main(String[] args) {
    		Triangle triangle = new Triangle();
    		triangle.length = 2;
    		triangle.width = 1;
    		triangle.style = "Rectangle";
    		
    		triangle.showStyle();
    		triangle.show();
    	}
    }
    

    输出结果如下:

    style:Rectangle
    length:2.0 width:1.0

    需要注意的是:在Java中不存在多继承,与C++等支持多继承语言不同,所以在转换代码的过程中需要注意,而Java想要实现多继承可以使用implements(实现)接口,在后续博客中将会解释接口知识。

    继承的优点:如果有两个类相似,那么它们会有许多重复的代码,导致后果就是代码量大,后期的维护性不高。通过继承就可以解决这个问题,将两段代码中相同的部分提取出来组成一个父类,实现代码的复用。

    继承的特点:

    1. 子类拥有父类除 private 以外的所有属性和方法
    2. 子类可以拥有自己的属性和方法
    3. 子类可以重写实现父类的方法
    4. Java 中的继承是单继承,一个类只有一个父类

    成员访问与继承

    由类的成员变量具有访问限制可知,private可以防止未经过授权而进行修改,在继承中,也不会超越private的访问权限,如果将上述程序中的length,width声明为private,则会存在错误,Triangle类将会无法直接使用length和width。对此,程序员通常使用访问器方法来进行访问私有成员。

    // A simple class hierarchy
    class TwoDShape{
    	private double length;
    	private double width;
    		
    	void show(){
    		System.out.println("length:" + length + " width:" + width);
    	}
    
    	public double getLength() {
    		return length;
    	}
    
    	public void setLength(double length) {
    		this.length = length;
    	}
    
    	public double getWidth() {
    		return width;
    	}
    
    	public void setWidth(double width) {
    		this.width = width;
    	}
    }
    	
    class Triangle extends TwoDShape{
    	private String style;
    	
    	double area(){
    		return getLength() * getWidth();
    	}
    	
    	public String getStyle() {
    		return style;
    	}
    
    	public void setStyle(String style) {
    		this.style = style;
    	}
    
    	void showStyle() {
    		System.out.println("style:" + style);
    	}
    }
    
    class Shapes {
    	public static void main(String[] args) {
    		Triangle triangle = new Triangle();
    		triangle.setLength(2);
    		triangle.setWidth(1);
    		triangle.setStyle("Rectangle");
    		
    		triangle.showStyle();
    		triangle.show();
    	}
    }
    

    输出结果如下:

    style:Rectangle
    length:2.0 width:1.0

    构造函数与继承

    如果超类与子类都存在构造函数,那么是由哪个构造函数来构造子类对象呢?答案是超类构造函数构造超类部分,子类构造函数构造子类部分。

    // A simple class hierarchy
    class TwoDShape{
    	private double length;
    	private double width;
    		
    	void show(){
    		System.out.println("length:" + length + " width:" + width);
    	}
    
    	public double getLength() {
    		return length;
    	}
    
    	public void setLength(double length) {
    		this.length = length;
    	}
    
    	public double getWidth() {
    		return width;
    	}
    
    	public void setWidth(double width) {
    		this.width = width;
    	}
    }
    	
    class Triangle extends TwoDShape{
    	private String style;
    	
    	Triangle(String style, double length, double width){
    		setLength(length);
    		setWidth(width);
    		this.style = style; 
    	}
    	
    	double area(){
    		return getLength() * getWidth();
    	}
    	
    	public String getStyle() {
    		return style;
    	}
    
    	public void setStyle(String style) {
    		this.style = style;
    	}
    
    	void showStyle() {
    		System.out.println("style:" + style);
    	}
    }
    
    class Shapes {
    	public static void main(String[] args) {
    		Triangle triangle = new Triangle("Rectangle", 2, 1);
    		
    		triangle.showStyle();
    		triangle.show();
    	}
    }
    

    输出结果如下:

    style:Rectangle
    length:2.0 width:1.0

    super关键字

    super关键字在子类内部使用,代表父类对象。

    使用super调用超类构造函数

    // A simple class hierarchy
    class TwoDShape{
    	private double length;
    	private double width;
    		
    	TwoDShape(double length, double width) {
    		this.length = length;
    		this.width = width;
    	}
    	void show(){
    		System.out.println("length:" + length + " width:" + width);
    	}
    
    	public double getLength() {
    		return length;
    	}
    
    	public void setLength(double length) {
    		this.length = length;
    	}
    
    	public double getWidth() {
    		return width;
    	}
    
    	public void setWidth(double width) {
    		this.width = width;
    	}
    }
    	
    class Triangle extends TwoDShape{
    	private String style;
    	
    	Triangle(String style, double length, double width){
    		super(length, width);
    		this.style = style; 
    	}
    	
    	double area(){
    		return getLength() * getWidth();
    	}
    	
    	public String getStyle() {
    		return style;
    	}
    
    	public void setStyle(String style) {
    		this.style = style;
    	}
    
    	void showStyle() {
    		System.out.println("style:" + style);
    	}
    }
    
    class Shapes {
    	public static void main(String[] args) {
    		Triangle triangle = new Triangle("Rectangle", 2, 1);
    		
    		triangle.showStyle();
    		triangle.show();
    	}
    }
    

    输出结果如下:

    style:Rectangle
    length:2.0 width:1.0

    子类构造方法需要调用父类的构造方法时,在子类的构造方法体里最前面的位置:super()

    使用super访问超类成员

    super访问超类成员的用法与this相似,只不过super引用的是子类的超类。

    这种用法多用于被子类覆盖的同名成员和同名方法。

    创建多级层次结构

    如果存在三个类,分别为A,B,C,而它们的关系为A是B的超类,B是C的超类,这样就形成了一个简单的多级层次结构,此时,C将继承A和B所有的成员。

    // A simple class hierarchy
    class TwoDShape{
    	private double length;
    	private double width;
    		
    	TwoDShape(double length, double width) {
    		this.length = length;
    		this.width = width;
    	}
    	void show(){
    		System.out.println("length:" + length + " width:" + width);
    	}
    
    	public double getLength() {
    		return length;
    	}
    
    	public void setLength(double length) {
    		this.length = length;
    	}
    
    	public double getWidth() {
    		return width;
    	}
    
    	public void setWidth(double width) {
    		this.width = width;
    	}
    }
    	
    class Triangle extends TwoDShape{
    	private String style;
    	
    	Triangle(String style, double length, double width){
    		super(length, width);
    		this.style = style; 
    	}
    	
    	double area(){
    		return getLength() * getWidth();
    	}
    	
    	public String getStyle() {
    		return style;
    	}
    
    	public void setStyle(String style) {
    		this.style = style;
    	}
    
    	void showStyle() {
    		System.out.println("style:" + style);
    	}
    }
    
    class ColorTriangle extends Triangle{
    	private String color;
    	
    	ColorTriangle(String color, String style, double length, double width) {
    		super(style, length, width);
    		
    		this.color = color;
    	}
    
    	public String getColor() {
    		return color;
    	}
    
    	public void setColor(String color) {
    		this.color = color;
    	}
    	
    	void showColor() {
    		System.out.println("Color:" + color);
    	}
    }
    
    class Shapes {
    	public static void main(String[] args) {
    		ColorTriangle triangle = new ColorTriangle("Red", "Rectangle", 2, 1);
    		
    		triangle.showColor();
    		triangle.showStyle();
    		triangle.show();
    	}
    }
    

    输出结果如下:

    Color:Red
    style:Rectangle
    length:2.0 width:1.0

    怎样调用构造函数

    对于多级层级结构来说,就会存在有构造函数使用的先后顺序的问题。

    因为super()必须是构造函数中的第一条语句,所以根据递归的思想,将会先调用第一个超类的构造函数,依次下来,最后构造最后一个子类构造函数。

    超类引用与子类对象

    Java是强类型语言,在类型方面十分严格,因此在超类对象与子类对象中如果出现需要转换时,该是如何操作的呢?

    以上面的Shapes.java程序为例,ColorTriangle是Triangle类的子类。

    ColorTriangle t1 = new ColorTriangle("Red", "Rectangle", 2, 1);
    Triangle t2 = new Triangle("Rectangle", 2, 1);
    
    t1 = t2;			//ERROR
    t2 = t1;			//OK
    

    对于这一小段代码可以简单的这样理解,子类的成员中包含了超类的所有成员,因此超类引用可以引用子类对象。

    所以,在构造中也可以直接使用子类对象来进行super()构造。

    Triangle(Triangle t1){
    	super(t1);
    	style = t1.style;
    }
    

    方法重写

    在类层次结构中,当子类中的方法与超类中方法有相同的签名和返回类型,就成称子类中的方法重写(override)了超类的方法。此时在子类中调用被重写的方法时,将会使用子类定义的方法,而超类的方法被覆盖。

    class Animal {
        public void bark() {
            System.out.println("动物叫!");
        }
    }
    
    class Dog extends Animal {
        public void bark() {
            System.out.println("汪!汪!汪!");
        }
    }
    
    public class test{
        public static void main(String args[]){
            Animal a = new Animal(); 
            Dog d = new Dog();   
    
             Animal b = new Dog(); 
    
            a.bark();
            d.bark();
            b.bark();
        }
    }
    

    输出结果如下:

    动物叫!
    汪!汪!汪!
    汪!汪!汪!

    方法重写也使得Java能够实现动态方法分配,而动态方法分配这个机制是Java实现运行时多态性的机制。

    抽象类

    在定义类时,前面加上abstract关键字修饰的类叫抽象类。 抽象类中有抽象方法,这种方法是不完整的,仅有声明而没有方法体。抽象方法声明语法如下:

    abstract void f();  //f()方法是抽象方法
    

    使用抽象类的主要情况:

    1. 在某些情况下,某个父类只是知道其子类应该包含怎样的方法,但无法准确知道这些子类如何实现这些方法。也就是说抽象类是约束子类必须要实现哪些方法,而并不关注方法如何去实现。
    2. 从多个具有相同特征的类中抽象出一个抽象类,以这个抽象类作为子类的模板,从而避免了子类设计的随意性。

    所以由上可知,抽象类是限制规定子类必须实现某些方法,但不关注实现细节。

    抽象类的规则:

    1. 用 abstract 修饰符定义抽象类
    2. 用 abstract 修饰符定义抽象方法,只用声明,不需要实现
    3. 包含抽象方法的类就是抽象类
    4. 抽象类中可以包含普通的方法,也可以没有抽象方法
    5. 抽象类的对象不能直接创建,通常是定义引用变量指向子类对象。
    abstract class TwoDShape{
    	private double length;
    	private double width;
    		
    	TwoDShape(double length, double width) {
    		this.length = length;
    		this.width = width;
    	}
    	void show(){
    		System.out.println("length:" + length + " width:" + width);
    	}
    
    	public double getLength() {
    		return length;
    	}
    
    	public void setLength(double length) {
    		this.length = length;
    	}
    
    	public double getWidth() {
    		return width;
    	}
    
    	public void setWidth(double width) {
    		this.width = width;
    	}
    	
    	abstract double area();
    }
    	
    class Triangle extends TwoDShape{
    	private String style;
    	
    	Triangle(String style, double length, double width){
    		super(length, width);
    		this.style = style; 
    	}
    	
    	double area(){
    		return getLength() * getWidth();
    	}
    	
    	public String getStyle() {
    		return style;
    	}
    
    	public void setStyle(String style) {
    		this.style = style;
    	}
    
    	void showStyle() {
    		System.out.println("style:" + style);
    	}
    }
    
    class Shapes {
    	public static void main(String[] args) {
    		Triangle triangle = new Triangle("Rectangle", 2, 1);
    		triangle.showStyle();
    		triangle.show();
    	}
    }
    

    输出结果如下:

    style:Rectangle
    length:2.0 width:1.0

    final关键字

    final关键字可以修饰类、方法、属性和变量

    1. final 修饰类,则该类不允许被继承,为最终类
    2. final 修饰方法,则该方法不允许被覆盖(重写)
    3. final 修饰属性:则该类的属性不会进行隐式的初始化(类的初始化属性必须有值)或在构造方法中赋值(但只能选其一)
    4. final 修饰变量,则该变量的值只能赋一次值,即常量

    Object类

    Java中定义了一个特殊的类Object类,它是所有类的隐式超类,换而言之,其他的类都是Object类的子类。

    方法目的
    clone()创建并返回此对象的一个副本。
    toString()返回该对象的字符串表示。
    notify()唤醒在此对象监视器上等待的单个线程。
    notifyAll()唤醒在此对象监视器上等待的所有线程。
    registerNatives()私有方法
    getClass()返回此 Object 的运行类。
    hashCode()用于获取对象的哈希值。
    equals(Object obj)用于确认两个对象是否“相同”。
    wait(long timeout)在其他线程调用此对象的 notify() 方法或 notifyAll() 方法,或 者超过指定的时间量前,导致当前线程等待。
    wait(long timeout, int nanos)在其他线程调用此对象的 notify() 方法或 notifyAll() 方法,或者其他某个线程中断当前线程,或者已超过某个实际时间量前,导致当前线程等待。
    wait()用于让当前线程失去操作权限,当前线程进入等待序列
    finalize()当垃圾回收器确定不存在对该对象的更多引用时,由对象的垃圾回收器调用此方法。

    1. 面向对象程序设计中的三个基本原则:封装、继承和多态。 ↩︎

    2. 在不同的地方,超类也可称为父类或基类,子类可被称为派生类。
      一般超类和父类对应子类,基类对应派生类。 ↩︎

    展开全文
  • Java继承、抽象、组合

    千次阅读 2020-10-11 21:58:41
    Java继承、抽象、组合类的继承Object类终结类与终结方法抽象类泛型类的组合包的应用本章小结 类的继承 类的继承 一种由已有的类创建新类的机制,是面向对象程序设计的基石之一通过继承,可以根据已有类来定义新类...

    类的继承

    类的继承
    一种由已有的类创建新类的机制,是面向对象程序设计的基石之一。通过继承,可以根据已有类来定义新类,新类拥有已有类的所有功能。
    Java只支持类的单继承,每个子类只能有一个直接父类
    父类是所有子类的公共属性及方法的集合,子类则是父类的特殊化
    继承机制可以提高程序的抽象程度,提高代码的可重用性

    基类和派生类

    • 基类(base class)
      也称超类(superclass)是被直接或间接继承的类

    • 派生类(derived-class)
      也称子类 (subclass)继承其他类而得到的类
      继承所有祖先的状态和行为
      派生类可以增加变量和方法
      派生类也可以覆盖(override)继承的方法

    子类对象与父类对象存在“IS A”(或“is a kind of”)的关系

    派生类产生的对象从外部来看,它应该包括

    • 与基类相同的接口
    • 可以具有更多的方法和数据成员
      其内包含着一个基类类型的子对象

    继承语法:

    class childClass extends parentClass
    { 
    	//类体
    }
    
    

    举个例子,在一个公司中,有普通员工(Employees)及管理人员(Magagers)两类人员
    职员对象(Employees)可能有的属性信息包括
    员工号(employeeNumber)
    姓名(name)
    地址(address)
    电话号码(phoneNumber)
    管理人员(Managers)除具有普通员工的属性外,还可能具有下面的属性
    职责(responsibilities)
    所管理的职员(listOfEmployees)

    //父类Employee
    class Employee
    {    
        int  employeeNumbe ;
        String  name, address, phoneNumber ;
    }
    //子类Manager
    class  Manager extends Employee 
    {
        //子类增加的数据成员
        String responsibilities, listOfEmployees;
    }
    
    

    需要注意的:
    子类不能直接访问从父类中继承的私有属性及方法,但可使用公有(及保护)方法进行访问

    public class B { 
       public int a = 10; 
       private int b = 20; 
       protected int c = 30; 
       public int getB()  { return b; } 
    } 
    public class A extends B { 
       public int d; 
       public void tryVariables() { 
          System.out.println(a);             //允许 
          System.out.println(b);             //不允许
          System.out.println(getB());        //允许 
          System.out.println(c);             //允许 
        } 
    }
    

    隐藏和覆盖

    子类对从父类继承来的属性变量及方法可以重新定义

    属性的隐藏

    class Parent {
        Number aNumber;
    }
    
    class Child extends Parent {
        Float aNumber;
    }
    
    
    • 子类中声明了与父类中相同的成员变量名,则从父类继承的变量将被隐藏
    • 子类拥有了两个相同名字的变量,一个继承自父类,另一个由自己声明
    • 当子类执行继承自父类的操作时,处理的是继承自父类的变量;而当子类执行它自己声明的方法时,所操作的就是它自己声明的变量

    访问被隐藏的父类属性

    • 调用从父类继承的方法,则操作的是从父类继承的属性
    • 使用super.属性
    class A1
    {   int x = 2;    
        public void setx(int i) 
        {   x = i;    }
        void printa()
        {System.out.println(x);}  
    }
    class B1 extends A1
    {   int x=100;
        void printb() 
        {  super.x = super.x +10 ;
           System.out.println("super.x=" + super.x + "  x= " + x);
        }  
    }
    
    public class Exam4_4Test 
    {  public static void main(String[] args)
        {   A1 a1 = new A1();  
             a1.setx(4);   
             a1.printa();
    
             B1 b1 = new B1();     
             b1.printb();     
             b1.printa();  
      
             b1.setx(6);  // 将继承x值设置为6
             b1.printb();     
             b1.printa();
             a1.printa();
        }  
    }
    

    运行结果:
    4
    super.x= 12 x= 100
    12
    super.x= 16 x= 100
    16
    4

    操作父类静态属性举例
    子类不能继承父类中的静态属性,但可以对父类中的静态属性进行操作。如在上面的例子中,将“int x = 2;”改为“static int x = 2;”,再编译及运行程序,会得到下面的结果
    4 super.x= 14 x= 100 14 super.x= 16 x= 100 16 16
    在上面的结果中,第一行及最后一行都是语句“a1.printa();”输出的结果,显然类B中的printb()方法修改的是类A中的静态属性x

    方法覆盖
    如果子类不需使用从父类继承来的方法的功能,则可以声明自己的同名方法,称为方法覆盖
    覆盖方法的返回类型,方法名称,参数的个数及类型必须和被覆盖的方法一模一样

    只需在方法名前面使用不同的类名或不同类的对象名即可区分覆盖方法和被覆盖方法

    覆盖方法的访问权限可以比被覆盖的宽松,但是不能更为严格

    方法覆盖的应用场合

    • 子类中实现与父类相同的功能,但采用不同的算法或公式
    • 在名字相同的方法中,要做比父类更多的事情
    • 在子类中需要取消从父类继承的方法

    注意事项
    必须覆盖的方法
    派生类必须覆盖基类中的抽象的方法,否则派生类自身也成为抽象类.
    不能覆盖的方法
    基类中声明为final的终结方法
    基类中声明为static 的静态方法
    调用被覆盖的方法
    super.overriddenMethodName();

    Object类

    Java程序中所有类的直接或间接父类,类库中所有类的父类,处在类层次最高点
    包含了所有Java类的公共属性,其构造方法是Object( )
    在这里插入图片描述

    包含的主要方法

    Object类定义了所有对象必须具有的状态和行为,较主要的方法如下

    • public final Class getClass()
      获取当前对象所属的类信息,返回Class对象

    • public String toString()
      返回当前对象本身的有关信息,按字符串对象返回

    • public boolean equals(Object obj)
      比较两个对象是否是同一对象,是则返回true

    • protected Object clone( )
      生成当前对象的一个拷贝,并返回这个复制对象

    • Public int hashCode()
      返回该对象的哈希代码值

    • protected void finalize() throws Throwable
      定义回收当前对象时所需完成的资源释放工作
      你的类不可以覆盖终结方法,即有final修饰的方法

    相等和同一
    两个对象具有相同的类型,及相同的属性值,则称二者相等(equal)
    如果两个引用变量指向的是同一个对象,则称这两个变量(对象)同一(identical)

    两个对象同一,则肯定相等
    两个对象相等,不一定同一

    比较运算符“==” 判断的是这两个对象是否同一

    clone方法

    根据已存在的对象构造一个新的对象
    在根类Object 中被定义为protected,所以需要覆盖为public
    实现Cloneable 接口,赋予一个对象被克隆的能力(cloneability)

    class MyObject implements Cloneable 
    {  //…
    }
    

    finalize方法

    在对象被垃圾回收器回收之前,系统自动调用对象的finalize方法
    如果要覆盖finalize方法,覆盖方法的最后必须调用super.finalize

    getClass方法

    final 方法,返回一个Class对象,用来代表对象隶属的类
    通过Class 对象,你可以查询Class对象的各种信息:比如它的名字,它的基类,它所实现接口的名字等。

    void PrintClassName(Object obj) {
        System.out.println("The Object's class is " +
                           obj.getClass().getName());
    }
    

    notify、notifyAll、wait方法

    final方法,不能覆盖
    这三个方法主要用在多线程程序中

    终结类与终结方法

    • 被final修饰符修饰的类和方法
    • 终结类不能被继承
    • 终结方法不能被当前类的子类重写

    终结类

    • 终结类的特点
      不能有派生类
    • 终结类存在的理由
      安全: 黑客用来搅乱系统的一个手法是建立一个类的派生类,然后用他们的类代替原来的类
      设计: 你认为你的类是最好的或从概念上你的类不应该有任何派生类

    举例:
    声明ChessAlgorithm 类为final 类

    final class ChessAlgorithm {   . . .   }
    

    如果写下如下程序:

    class BetterChessAlgorithm extends ChessAlgorithm {}
    

    编译器将显示一个错误
    Chess.java:6: Can’t subclass final classes: class ChessAlgorithm
    class BetterChessAlgorithm extends ChessAlgorithm {
    ^
    1 error

    终结方法

    • 特点
      不能被派生类覆盖
    • 终结方法存在的理由
      对于一些比较重要且不希望子类进行更改的方法,可以声明为终结方法。可防止子类对父类关键方法的错误重写,增加了代码的安全性和正确性
      提高运行效率。通常,当java运行环境(如java解释器)运行方法时,它将首先在当前类中查找该方法,接下来在其超类中查找,并一直沿类层次向上查找,直到找到该方法为止

    在这里插入图片描述

    抽象类

    代表一个抽象概念的类
    没有具体实例对象的类,不能使用new方法进行实例化

    类前需加修饰符abstract
    可包含常规类能够包含的任何东西,例如构造方法,非抽象方法
    也可包含抽象方法,这种方法只有方法的声明,而没有方法的实现

    • 存在意义
      抽象类是类层次中较高层次的概括,抽象类的作用是让其他类来继承它的抽象化的特征。
      抽象类中可以包括被它的所有子类共享的公共行为
      抽象类可以包括被它的所有子类共享的公共属性
      在程序中不能用抽象类作为模板来创建对象;
      在用户生成实例时强迫用户生成更具体的实例,保证代码的安全性

    几何形状的例子

    将所有图形的公共属性及方法抽象到抽象类Shape。再将2D及3D对象的特性分别抽取出来,形成两个抽象类TwoDimensionalShape及ThreeDimensionalShape

    • 2D图形包括Circles、Triangles、Rectangles和Squares
    • 3D图形包括Cube、Sphere、或Tetrahedron
    • 在UML中,抽象类的类名为斜体,以与具体类相区别
      在这里插入图片描述

    抽象类声明的语法形式为

    abstract class Number {
        . . .
    }
    

    如果写:
    new Number();
    编译器将显示错误

    抽象方法
    声明的语法形式为

    public abstract <returnType> <methodName>(...);
    

    仅有方法头,而没有方法体和操作实现
    具体实现由当前类的不同子类在它们各自的类声明中完成
    抽象类可以包含抽象方法

    需注意的问题

    1. 一个抽象类的子类如果不是抽象类,则它必须为父类中的所有抽象方法书写方法体,即重写父类中的所有抽象方法
    2. 只有抽象类才能具有抽象方法,即如果一个类中含有抽象方法,则必须将这个类声明为抽象类
    3. 除了抽象方法,抽象类中还可以包括非抽象方法

    抽象方法的优点

    隐藏具体的细节信息,所有的子类使用的都是相同的方法头,其中包含了调用该方法时需要了解的全部信息
    强迫子类完成指定的行为,规定其子类需要用到的“标准”行为

    一个绘图的例子
    各种图形都需要实现绘图方法,可在它们的抽象父类中声明一个draw抽象方法

    abstract class GraphicObject {
        int x, y;
        void moveTo(int newX, int newY) { . . . }
        abstract void draw();
    }
    

    然后在每一个子类中重写draw方法,例如:

    class Circle extends GraphicObject {
        void draw() {  . . .  }
    }
    class Rectangle extends GraphicObject {
        void draw() {  . . .  }
    }
    

    在这里插入图片描述

    贷款(Loan)分为许多种类,如租借(Lease)、抵押(Mortgage)、房屋贷款(HouseLoan)、汽车贷款(CarLoan)等
    将Loan声明为抽象类,并指定所有的子类对象都应具有的行为,如计算月还款值(calculateMonthlyPayment),还款(makePayment),取得客户信息(getClientInfo),其中前两个因贷款种类不同计算方法也不同,可声明为抽象方法,Loan的所有子类都必须对这两个抽象方法进行重写

    public abstract class Loan { 
       public abstract float calculateMonthlyPayment(); 
       public abstract void makePayment(float amount); 
         public Client getClientInfo() {  } 
    }
    

    包的应用

    为了解决类名冲突,Java提供包来管理类名空间
    Java利用包来组织相关的类,并控制访问权限
    包是一种松散的类的集合,利用包来管理类,可实现类的共享与复用
    同一包中的类在默认情况下可以互相访问,通常把需要在一起工作的类放在一个包里

    Java基础类库

    Java提供了用于语言开发的类库,称为Java基础类库(JFC,Java Foundational Class) ,也称应用程序编程接口(API,Application Programming Interface),分别放在不同的包中
    Java提供的包主要有
    java.lang,java.io,java.math,java.util
    java.applet,java.awt,java.awt.datatransfer
    java.awt.event,java.awt.image,java.beans
    java.net,java.rmi,java.security,java.sql等

    本章小结

    在这里插入图片描述

    展开全文
  • JAVA继承、封装和多态详解

    千次阅读 2015-05-22 10:35:24
     Java继承用extends关键字来实现,被继承的类成为父类,实现继承的类被称为子类。子类和父类的关系就比如现实生活中儿子与父亲的关系。子类继承父类所有的“特点”,子类是父类的扩展,子类是一种特殊的父类,...
  • java继承关系

    千次阅读 2017-03-08 12:43:06
    Tips:1)Java只支持单重继承,即每一个类有且仅有一个直接父类,一个父类可以产生多个子类  2)子类只能继承父类中非private的成员变量  3)子类的成员变量和父类的成员变量重名时,父类的成员变量将被覆盖,而...
  • Java继承与多态总结

    千次阅读 2015-04-07 14:10:29
    继承的类称为子类、派生类,而被继承类称为父类、基类或超类。通过继承,使得子类具有父类的属性和方法,同时子类也可以通过加入新的属性和方法或者修改父类的属性和方法建立新的类层次。 继承机制体现了面向对象...
  • final类的另外一个重要应用就是,防止动态绑定使计算机性能消耗太大。如果一个方法没有被覆盖并且很短,那么编译器就能对他进行优化处理,这个过程又称为内联。例如,内联调用e.getName()将被替换为访问e.name域。...
  • 如何防止类被继承

    2016-03-12 10:56:05
    java中如何防止类被继承
  • 「万字图文」史上最姨母级Java继承详解

    千次阅读 多人点赞 2020-11-19 10:01:46
    三大特征紧密联系而又有区别,本课程就带你学习Java继承。 你可能不知道继承到底有什么用,但你大概率曾有过这样的经历:写Java项目/作业时候创建很多相似的类,类中也有很多相同的方法,做了很多重复的工作量,...
  • Java基础系列15-面向对象之继承

    千次阅读 2021-08-17 09:09:34
    继承概述1.1 继承的好处和弊端1.2 Java继承的特点1.3 Java继承中成员变量的特点1.4 继承案例1.4.1 父子类案例1.4.2 多重继承案例二. super关键字以及继承中的方法重写2.1 super关键字的概述和使用2.2 Java继承中...
  • java继承之类、超类和子类

    千次阅读 2018-04-23 22:54:24
    继承其实在生活中到处都是例子,比如哪个富豪去世了,然后他的子女继承了他的财产啊,或者是有人说你跟你爸或者你妈长得像等等,,都是继承,而在java中的继承,其实是为了减少代码的数量,而重复使用了其上一个类的...
  • Java防止xss攻击

    千次阅读 2016-03-29 13:02:07
    首先说一下思路,防止这种类似于注入攻击,就是使用拦截器(Filter)处理特殊字符或过滤特殊字符 今天介绍一个方法,利用覆盖Servlet的getParameter方法达到处理特殊字符的目的来解决(防止)Xss攻击 web.xml ...
  • Java基础——继承与多态

    千次阅读 多人点赞 2020-04-11 10:20:00
    继承1.介绍2.super关键字2.1 调用父类的构造方法2.2 构造方法链2.3 调用父类的方法3.方法重写4.Object类及其常用方法4.1 toString()方法4.2 equals()方法二. 多态5.1 介绍5.2 动态绑定5.3 对象转换和instanceof...
  • Swift和Java对于继承大部分是一样的,只是语法稍有不同,Java继承用extends关键字,Swift用冒号来实现继承Java中所有的类默认继承于Object类,Swift则没有这个规定。...Java和Swift都是用final来防止
  • java 防止xss攻击

    千次阅读 2014-10-27 14:50:21
     关键是XssHttpServletRequestWrapper的实现方式,继承servlet的HttpServletRequestWrapper,并重写相应的几个有可能带xss攻击的方法,如: Java代码  package  cn.pconline.morden.filter;...
  • Java 继承、多态与类的复用

    万次阅读 多人点赞 2016-10-12 17:09:30
    本文结合Java的类的复用对面向对象两大特征继承和多态进行了全面的介绍。首先,我们介绍了继承的实质和意义,并探讨了继承,组合和代理在类的复用方面的异同。紧接着,我们根据继承引入了多态,介绍了它的实现机制和...
  • java 防止表单重复提交

    千次阅读 2009-12-07 18:53:00
    防止表单重复提交,或者是防止按F5 刷新提交表单。 在WEB开发中是经常会碰到这样的问题的。 目前主流的解决方法有以下三种: 1、采用脚本来解决 2、重定向到别的页面 3、使用s:token 标签 由于我是使用S2SH来...
  • ------- android培训、java培训、期待与您交流!  ---------- 父类与子类关系继承关系抽象类接口多态 多态的体现多态的前提多态的好处多态的弊端 多态中成员的特点Object 类 父类与子类关系:继承关系   ...
  • 防止拓展与重写 —final关键字二. 多态6.1 介绍6.2 动态绑定6.3 对象转换和instanceof()运算符6.3.1 对象转换6.3.2instanceof运算符 一. 继承 1.介绍 多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中...
  • JAVA服务端防止XSS攻击

    千次阅读 2019-05-06 11:11:25
    JAVA服务端防止XSS攻击 在网站登录页面用户名输入 1"><script>alert(10350)</script> 密码随便输然后点击登陆如下图 ![在这里插入图片描述]...
  • (2)如果在一个子类继承的多个父类中拥有相同方法,子类中有没有覆盖该方法,那么调用该方法时将产生歧义,无法判断应该调用哪个父类的方法正因为有以上的致命缺点,所以java中禁止一个类继承...
  • Java封装、继承和多态

    万次阅读 2016-11-24 10:19:52
    说白点,我们之所以要用到封装,就是为了防止有人恶意修改你的数据。 我们来看下面一个列子你就明白了 Cat.height=25; 你可以把这件事情看作是直接通过远程控制修改Cat的实例变量。若远程控制落入了不当之...
  • Java 继承 ( inheritance)继承java面向对象编程技术的一块基石,因为它允许创建分等级层次的类。继承可以理解为一个对象从另一个对象获取属性的过程。如果类A是类B的父类,而类B是类C的父类,我们也称C是A的...
  • Java面向对象继承与组合的问题

    千次阅读 2007-03-17 15:18:00
    Java面向对象继承与组合的问题
  • 什么面向对象?一句话,万物皆对象。 比如,人是一个类,男人或女人就是人类的...封装、继承、多态。 首先,我们先通过一个有趣的比喻说明来理解。  首先说定义一类人被封装成“贪官”,我们就是平民老
  • java面向对象的封装继承多态特性

    万次阅读 2019-02-18 16:05:56
    我这里只说传统的三大特性:继承,封装,多态。 1.继承:  在王者荣耀中,武器是物品的一种,也是有名称和价格。在设计这个类的时候,可以让武器继承物品,从而继承名称和价格属性。  物品类Item,有属性name,...
  • Java中的封装,继承和多态(详解)

    千次阅读 多人点赞 2021-05-21 22:07:08
    目录封装继承 封装 所谓的封装就是把类的属性和方法使用private修饰,不允许类的调用者直接访问,我们定义如下一个类,可以看到所有的成员变量和成员方法都使用private修饰了,我们现在来使用一下这个类。 当我们...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 129,276
精华内容 51,710
关键字:

java防止继承

java 订阅