栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

java 面向对象 (4)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

java 面向对象 (4)

继承

java.lang.Object 类是所有类的父类(直接&间接)

理解继承

子类是对父类的扩展,子类是一种特殊的父类

修饰符 class SubClass extends SuperClass
{
     //类定义部分
}
  • extends 关键字在英文中为扩展的意思
  • 子类扩展了父类,将获得父类的全部成员变量和方法
  • 但不能获得父类的构造器
  • Java 类只能有一个直接父类,但可以有无限多个间接父类
  • 如果定义一个类时未显式指定直接父类,则默认扩展 java.lang.Object 类
重写父类的方法
class A
{
	public void a()
	{
		System.out.println("a");
	}
}

public class HelloWorld extends A
{
	   public void a()
	   {
		      System.out.println("Hi~");
	   }
	   public static void main(String[] args)
	   {
			  new HelloWorld().a();
		      			
	   }
}
  • 两同两小一大:
    • 方法名相同
    • 形参列表相同
    • 子类方法返回值类型 <= 父类方法返回值类型
    • 子类方法声明抛出的异常类 <= 父类方法声明抛出的异常类
    • 子类方法的访问权限 >= 父类方法的访问权限
  • 重写和被重写的方法要么都是类方法,要么都是实例方法
    • 否则将引发编译错误
  • 父类方法中 private 修饰的方法子类无法访问,也无法重写
    • 系统会将子类中所谓重写的方法当成一个新的方法
重载和重写

重载(overload):

发生在同一个类的多个同名方法之间

重写(override):

发生在子类和父类的同名方法之间

两者比较:

没有任何意义

两者联系:

子类会获得父类的方法,如果子类定义了一个与父类方法方法名相同、但形参列表不同的方法,就会形成父类方法和子类方法之间的重载

class A
{
	public void a()
	{
		   System.out.println(1);
	}
}

public class HelloWorld extends A
{
	public void a(int i)
	{
		   System.out.println(2);
	}
	
	public static void main(String[] args)
	{
		   new HelloWorld().a();
		   new HelloWorld().a(18);
		   
	}
}



class A
{
	public void a()
	{
		   System.out.println(1);
	}
}

public class HelloWorld extends A
{
	public void a()
	{
		   System.out.println(2);
	}
	
	public static void main(String[] args)
	{
		   new HelloWorld().a();
		   new A().a();
		   
	}
}
覆盖与隐藏

重写父类(类&实例)方法 = 覆盖父类(类&实例)方法

定义同名的子类的(类&实例)变量  =  隐藏同名的父类的(类&实例)变量

  • 如果覆盖的是类方法
    • 通过父类类名作为前缀指定调用即可
  • 如果隐藏的是类变量
    • 通过父类类名作为前缀指定调用即可
super 限定

限定子类的实例对象调用它从父类中继承的但被覆盖了的实例方法和被隐藏的实例变量

  • 与 this 关键字一样, super 关键字不能出现在 static 修饰的方法中
    • 否则将无法限定有效的对象
  • 在某个方法中访问名为 a 的成员变量时,没有显式调用者,则系统的查找顺序为:
    1. 该方法中是否有名为 a 的局部变量
    2. 当前类中是否有名为 a 的成员变量
    3. 当前类的直接父类中是否有名为 a 的成员变量
    4. 依次上溯 a 的所有父类直到 java.lang.Object 类
    5. 编译错误
调用父类构造器

this 关键字:

 同一类中,调用重载的构造器

super 关键字:

 子类中,调用父类的构造器

class A
{
	 public int a;
	 public int b;
	 public A(int a , int b)
	 {
		 this.a = a;
		 this.b = b;
	 }
}

public class HelloWorld extends A
{
       int c;
	   public HelloWorld(int a , int b , int c)
	   {
		      super(a , b);
		      this.c = c;
	   }
	   public static void main(String[] args)
	   {
			  HelloWorld h = new HelloWorld(1 , 2 , 3);
			  System.out.println(h.a + "---" + h.b + "---" + h.c);
		      			
	   }
}
  • super 关键字根据形参列表来决定调用父类中的哪个构造器
    • 需要省略形参类型
  • super 关键字调用父类构造器也必须作为子类构造器执行体的第一条语句
    • this 调用和 super 调用不会同时出现
构造器的上溯

父类构造器总会在子类构造器之前执行

创建任何 Java 对象,最先执行的总是 java.lang.Object 类的构造器

class A
{
	 public A()
	 {
		 System.out.println("执行 A 类无参数构造器");
	 }
}

class B extends A
{
	public B()
	{
		System.out.println("执行 B 类无参数的构造器");
	}
	
	public B(int b1)
	{
		System.out.println("执行 B 类带一个参数的构造器");
	}
	
	public B(int b1 , int b2)
	{
		this(b1);
		System.out.println("执行 B 类带两个参数的构造器");
	}
	
}

public class HelloWorld extends B
{
       public HelloWorld()
	   {
		   super(1 , 2);
		   System.out.println("执行 HelloWorld 类无参数的构造器");
	   }
	   
	   public static void main(String[] args)
	   {
			  new HelloWorld();
		      			
	   }
}
  • 子类构造器调用父类构造器顺序:
    1. super 关键字显式调用父类构造器
    2. this 关键字显式调用同类中重载的构造器
    3. 既无 super 也无 this 关键字,隐式调用父类无参数构造器
多态

Java 允许把一个子类对象直接赋给一个父类引用变量,这是系统自动支持的向上转型(upcasting)

多态性

Java 引用变量有两个类型:一个是编译时类型,一个是运行时类型

编译时类型  =  声明该变量时使用的类型

运行时类型  =  实际赋给变量的对象的类型

class A
{
	public int a = 18;
	public void a1()
	{
		System.out.println("父类 A 的实例方法");
	}
	public void a2()
	{
		System.out.println("父类 A 的被覆盖的实例方法");
	}	
}

public class HelloWorld extends A
{
	   public String a = "Hi~";
	   
	   public void a2()
	   {
		   System.out.println("子类 HelloWorld 覆盖父类的实例方法");
	   }
	   
	   public void foo()
	   {
		   System.out.println("子类 HelloWorld 的实例方法");
	   }
	   
	   public static void main(String[] args)
	   {
			  A A1 = new A();                        //无多态现象
			  System.out.println(A1.a);
			  A1.a1();
			  A1.a2();
			  
			  
			  HelloWorld h = new HelloWorld();       //无多态现象
		      System.out.println(h.a);
			  h.a1();
			  h.a2();
			  h.foo();
			  
			  
			  A A2 = new HelloWorld();               //发生多态
			  System.out.println(A2.a);
			  A2.a1();
			  A2.a2();
			  //A2.foo();     //编译错误,编译时类型 A 未包含 foo() 方法
			  			
	   }
}
  • 方法行为总是表现出:
    • 编译时类型包含的且未被运行时类型重写的行为特征
    • 运行时类型重写了的编译时类型的行为特征
    • 不能表现出编译时类型未包含但运行时类型包含的方法
      • 即使该引用变量所引用的对象中的确包含了这些方法
      • 可以通过强制类型转换来实现调用运行时类型独有的方法
    • 即相同编译时类型的变量调用了同一个方法时呈现出了不同的行为特征,这就是多态
  • 成员变量不具备多态性:
    • 通过引用变量访问其包含的成员变量时
    • 系统总是访问该引用变量编译时类型所定义的成员变量
引用变量的强制转换

引用类型的强制转换只能在具有继承关系的两个类型之间进行

子类实例  ——>  父类类型:

  • 自动向上转型(upcasting)

父类实例  ——> 子类类型:

  • (targetType)variable
  • 必须满足编译时类型为父类,运行时类型为子类(实际上是子类实例)
public class HelloWorld 
{
	   
	   public static void main(String[] args)
	   {
			  		Object a1 = "Hi~";
					String a2 = (String)a1;
					System.out.println(a1);
					System.out.println(a2);
					
					
					Object b1 = Integer.valueOf(18);
					Integer b2 = (Integer)b1;
					System.out.println(b1);
					System.out.println(b2);
					
           
                    String b3 = (String)b1;
					
           
           
                    String b4 = (String)b2;
					
	   }
}
  • 为了使程序更加健壮:
    • 在进行引用类型之间的强制类型转换之前
    • 应该使用 instanceof 运算符判断是否可以转换成功
    • 从而避免出现 java.lang.ClassCastException 异常
instanceof 运算符

用于判断前面的对象是否为后面的类(或其子类)或接口(其实现类)的实例,即是否可以进行强制类型转换

public class HelloWorld 
{
	   
	   public static void main(String[] args)
	   {
			  		Object a1 = "Hi~";
                    
					
					System.out.println(a1 instanceof Object);
					
					
					System.out.println(a1 instanceof String);
					
					
					System.out.println(a1 instanceof Math);
					
					
					System.out.println(a1 instanceof Comparable);
					
					
           
					String a2 = "Hi~";
                    

					System.out.println(a2 instanceof Math);
					
					
	   }
}
  • instanceof 判断后:

    • 返回 true —— 可以进行强制类型转换
    • 返回 false —— 不可进行强制类型转换
  • 总结:

    • 编译时类型决定能不能使用 instanceof 运算符
    • 运行时类型决定能不能强制类型转换成功
组合

继承破坏了封装

继承的注意要点

尽量不要在父类构造器中调用将要被子类重写的方法

class A
{
	public A()
	{
		a();
	}
	
	public void a()
	{
		System.out.println("父类 A 中被将子类重写覆盖的实例方法 a()");
	}
}

public class HelloWorld extends A
{
	   private String s;
	   
	   public void a()
	   {
		   System.out.println("子类 HelloWorld 中重写覆盖父类的实例方法 a() 的实例方法 a()" + s.length());
	   }
	   
	   public static void main(String[] args)
	   {
		   HelloWorld h = new HelloWorld();
		   
	   }
}
  • 子类可以直接访问父类的成员变量和方法
  • 造成了子类和父类的严重耦合
  • 为了保证良好的封装性,设计父类应该遵循以下几点规则:
    • 尽量隐藏父类的内部数据,尽量把所有的成员变量设置为 private 访问权限
    • 父类中的工具方法(辅助其他方法的方法)设置为 private 访问权限
    • 父类中需要被调用的但不希望被子类重写的方法设置为 public final
    • 父类中需要被子类重写但不希望被其他类自由访问的方法设置为 protected 访问权限
子类的存在问题

派生子类前,先找个漂亮的借口吧:

  • 子类需要增加独有的属性
  • 子类需要增加独有的方法
class A
{
	public int i;
	
	private A(int i)           //private 修饰构造器,该类将无法被继承
	{
		this.i = i;
		System.out.println(i);
	}
	
	public static A a(int i)
	{
		return new A(i);
	}

}
public class HelloWorld 
{
	   public static void main(String[] args)
	   {
		   A a1 = A.a(0);
		   A a2 = A.a(18);
	   }
}
  • 如果希望设计成不可被继承的最终类:

    • 使用 final 修饰该类
    • 或使用 private 修饰该类的构造器
      • 保证子类无法调用父类的构造器,也就无法继承该类
      • 可以为该类另外提供一个 public 的静态方法
      • 作为该类的访问点以创建该类的实例
组合实现的复用

通过在一个类里面保存另一个类的实例对象的引用

class A
{
	private void a1()         //pirvate 修饰的实例方法
	{
		System.out.println("a1");
	}
	
	public void a2()          //public 修饰的实例方法
	{
		this.a1();
        System.out.println("a2");
	}
}

class B
{
	private A a;              //将类 A 的一个实例对象 a 作为类 B 的一个成员变量
	
	public B(A a)
	{
		this.a = a;
	}
	
	public void a2()
	{
		a.a2();
	}
	
	public void b1()
	{
		System.out.println("b1");
	}
}

class C
{
	private A a;              //将类 A 的一个实例对象 a 作为类 C 的一个成员变量
	
	public C(A a)
	{
		this.a = a;
	}
	
	public void a2()
	{
		a.a2();
	}
	
	public void c1()
	{
		System.out.println("c1");
	}
}

public class HelloWorld 
{
	   public static void main(String[] args)
	   {
		   A a = new A();
		   B b = new B(a);
		   C c = new C(a);
		   b.a2();
		   b.b1();
		   c.a2();
		   c.c1();
		   
	   }
}
  • 即把旧类(被组合的类)的一个实例对象作为新类(组合成的类)的一个成员变量组合进来:
    • 旧类的实例对象需要使用 private 修饰
    • 可以直接复用旧类的 public 修饰的方法
    • 可以间接复用旧类的 private 修饰的方法
类类之间的结构

继承:

       1. 一般  —> 特殊  =  is a 

       2. 从多个子类中抽象出共有的父类

组合:

       1. 整体  —>  部分  =  has a

       2. 从多个整体类中提取出被组合的类

关于性能和选择

用动物合成一匹狼毫无意义,同样,用轮胎派生一辆车也毫无意义

  • 采用继承的设计:

    • 父类定义了2个实例变量

    • 子类定义了3个实例变量

    • 从父类那继承,分配2块内存区域

    • 创建子类实例,分配3块内存区域

  • 采用组合的设计:

    • 旧类定义了2个实例变量
    • 新类定义了3个实例变量
    • 先创建嵌入类实例,分配2块内存区域
    • 再创建整体类实例,分配3块内存区域
    • 只是需要多用一个引用变量来引用嵌入类的实例对象
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/972684.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号