`
lysvanilla
  • 浏览: 80665 次
  • 性别: Icon_minigender_1
  • 来自: 湖南
社区版块
存档分类
最新评论

Java SE 学习笔记03 代码

 
阅读更多

关于父类与子类在属性和方法调用的代码

 

Java代码 复制代码 收藏代码
  1. /**
  2. * 方法重写
  3. */
  4. package org.sean.module03;
  5. /**
  6. * 类变量指的是属于类,通过类名就有可以访问的变量
  7. *
  8. * 实例变量指的是属于类的实例,通过对象可以访问实例变量,但是通过类名不能访问实例变量
  9. *
  10. * 同样,静态方法属于一个类,通过类名就可以访问静态方法,而实例方法属于对象,通过对象可以访问
  11. *
  12. * 所谓隐藏:子类隐藏父类的属性和静态方法,通过子类对象,不能访问父类隐藏了的属性和静态方法(属性和静态方法不存在多态性)
  13. *
  14. * 但是将子类对象转换为父类对象之后,可以访问父类中被隐藏的属性和静态方法
  15. *
  16. * 所谓覆盖(重写): 子类能够覆盖父类的实例方法,通过子类对象,不能访问父类被覆盖了的实例方法
  17. *
  18. * 将子类转换为父类对象后,也不能访问父类中被覆盖的实例方法。
  19. *
  20. * 结论:属性和静态方法只能被隐藏,实例方法只能被覆盖(重写)
  21. *
  22. * @author 不落的太阳(Sean Yang)
  23. */
  24. class Parent2 {
  25. // 类变量,Parent的类别
  26. public static String kind = "org.sean.module03.CoverAndHide.Parent";
  27. // 类变量,Parent的年龄
  28. public static int age = 50;
  29. // 实例变量,Parent的名称
  30. public String name = "Parent";
  31. /** 静态方法,获得Parent的类别 */
  32. public static String getKind() {
  33. System.out.println("parent getKind() method called");
  34. return kind;
  35. }
  36. /** 静态方法,获得Parent的年龄 */
  37. public static int getAge() {
  38. System.out.println("parent getAge() method called");
  39. return age;
  40. }
  41. /** 实例方法,获得Parent的名称 */
  42. public String getName() {
  43. System.out.println("parent getName() method called");
  44. return this.name;
  45. }
  46. }
  47. class Child2 extends Parent2 {
  48. // 类变量,Child的类别
  49. public static String kind = "org.sean.module03.CoverAndHide.Child";
  50. // 类变量,Child的年龄
  51. public static int age = 25;
  52. // 实例变量,Child的名称
  53. public String name = "child";
  54. /** 静态方法,获得Child的类别 */
  55. public static String getKind() {
  56. System.out.println("child getKind() method called");
  57. return kind;
  58. }
  59. /** 静态方法,获得Child的年龄 */
  60. public static int getAge() {
  61. System.out.println("child getAge() method called");
  62. return age;
  63. }
  64. /** 实例方法,获得Child的名称 */
  65. public String getName() {
  66. System.out.println("child getName() method called");
  67. return this.name;
  68. }
  69. /** 实例方法,获得Parent的名称 */
  70. public String getParentName() {
  71. return super.name;
  72. }
  73. /** 静态方法,获得Parent的类别 */
  74. public static String getParentKind() {
  75. return Parent2.kind;
  76. }
  77. }
  78. public class CoverAndHide {
  79. @SuppressWarnings("static-access")
  80. public static void main(String[] args) {
  81. Child2 child = new Child2();
  82. System.out.println("child name is " + child.name + ", child age is "
  83. + child.age + " ,kind is " + child.kind);// 此处得到都是Child类的变量值
  84. /** 将Child类型转换为Parent类型,即多态情况 */
  85. // Parent2 parent = child;
  86. Parent2 parent = new Child2();
  87. System.out.println("转换为Parent之后的name is " + parent.name + ", age is "
  88. + parent.age + " ,kind is " + parent.kind);
  89. /**
  90. * 结论:
  91. *
  92. * 父类的实例变量和类变量能被子类的同名变量遮盖(隐藏),将子类对象转换为父类对象后,可以访问父类对象的实例变量和类变量
  93. *
  94. * 在子类中如果需要访问父类中被隐藏的实例变量,需要使用"super.属性名"
  95. *
  96. * 在子类中如果需要访问父类中被隐藏的类变量,需要使用"父类名.属性名"
  97. */
  98. System.out.println("子类访问父类被隐藏的实例变量:" + child.getParentName());
  99. System.out.println("子类访问父类被隐藏的类变量:" + child.getParentKind());
  100. /** 继承时方法的覆盖与隐藏问题 */
  101. child.getName();
  102. child.getKind();
  103. parent.getName();
  104. parent.getKind();
  105. /**
  106. * 结论:
  107. *
  108. * 父类的静态方法被子类的同名静态方法隐藏,而父类的实例方法被子类的实例方法覆盖(重写)
  109. *
  110. * 将子类转换为父类对象后(或者多态),可以访问父类的静态方法,但不能访问父类的实例方法
  111. */
  112. }
  113. }
/**
 * 方法重写
 */
package org.sean.module03;

/**
 * 类变量指的是属于类,通过类名就有可以访问的变量
 * 
 * 实例变量指的是属于类的实例,通过对象可以访问实例变量,但是通过类名不能访问实例变量
 * 
 * 同样,静态方法属于一个类,通过类名就可以访问静态方法,而实例方法属于对象,通过对象可以访问
 * 
 * 所谓隐藏:子类隐藏父类的属性和静态方法,通过子类对象,不能访问父类隐藏了的属性和静态方法(属性和静态方法不存在多态性)
 * 
 * 但是将子类对象转换为父类对象之后,可以访问父类中被隐藏的属性和静态方法
 * 
 * 所谓覆盖(重写): 子类能够覆盖父类的实例方法,通过子类对象,不能访问父类被覆盖了的实例方法
 * 
 * 将子类转换为父类对象后,也不能访问父类中被覆盖的实例方法。
 * 
 * 结论:属性和静态方法只能被隐藏,实例方法只能被覆盖(重写)
 * 
 * @author 不落的太阳(Sean Yang)
 */
class Parent2 {

	// 类变量,Parent的类别
	public static String kind = "org.sean.module03.CoverAndHide.Parent";
	// 类变量,Parent的年龄
	public static int age = 50;
	// 实例变量,Parent的名称
	public String name = "Parent";

	/** 静态方法,获得Parent的类别 */
	public static String getKind() {
		System.out.println("parent getKind() method called");
		return kind;
	}

	/** 静态方法,获得Parent的年龄 */
	public static int getAge() {
		System.out.println("parent getAge() method called");
		return age;
	}

	/** 实例方法,获得Parent的名称 */
	public String getName() {
		System.out.println("parent getName() method called");
		return this.name;
	}
}

class Child2 extends Parent2 {

	// 类变量,Child的类别
	public static String kind = "org.sean.module03.CoverAndHide.Child";
	// 类变量,Child的年龄
	public static int age = 25;
	// 实例变量,Child的名称
	public String name = "child";

	/** 静态方法,获得Child的类别 */
	public static String getKind() {
		System.out.println("child getKind() method called");
		return kind;
	}

	/** 静态方法,获得Child的年龄 */
	public static int getAge() {
		System.out.println("child getAge() method called");
		return age;
	}

	/** 实例方法,获得Child的名称 */
	public String getName() {
		System.out.println("child getName() method called");
		return this.name;
	}

	/** 实例方法,获得Parent的名称 */
	public String getParentName() {
		return super.name;
	}

	/** 静态方法,获得Parent的类别 */
	public static String getParentKind() {
		return Parent2.kind;
	}
}

public class CoverAndHide {

	@SuppressWarnings("static-access")
	public static void main(String[] args) {
		Child2 child = new Child2();
		System.out.println("child name is " + child.name + ", child age is "
				+ child.age + " ,kind is " + child.kind);// 此处得到都是Child类的变量值
		/** 将Child类型转换为Parent类型,即多态情况 */
		// Parent2 parent = child;
		Parent2 parent = new Child2();
		System.out.println("转换为Parent之后的name is " + parent.name + ", age is "
				+ parent.age + " ,kind is " + parent.kind);
		/**
		 * 结论:
		 * 
		 * 父类的实例变量和类变量能被子类的同名变量遮盖(隐藏),将子类对象转换为父类对象后,可以访问父类对象的实例变量和类变量
		 * 
		 * 在子类中如果需要访问父类中被隐藏的实例变量,需要使用"super.属性名"
		 * 
		 * 在子类中如果需要访问父类中被隐藏的类变量,需要使用"父类名.属性名"
		 */
		System.out.println("子类访问父类被隐藏的实例变量:" + child.getParentName());
		System.out.println("子类访问父类被隐藏的类变量:" + child.getParentKind());

		/** 继承时方法的覆盖与隐藏问题 */
		child.getName();
		child.getKind();
		parent.getName();
		parent.getKind();
		/**
		 * 结论:
		 * 
		 * 父类的静态方法被子类的同名静态方法隐藏,而父类的实例方法被子类的实例方法覆盖(重写)
		 * 
		 * 将子类转换为父类对象后(或者多态),可以访问父类的静态方法,但不能访问父类的实例方法
		 */
	}
}

 

 

关于父类和子类加载顺序的代码

 

Java代码 复制代码 收藏代码
  1. /**
  2. * 类的加载顺序
  3. */
  4. package org.sean.module03;
  5. /**
  6. * 父类的静态代码块--->子类的静态代码块--->父类的初始化块 --->父类的构造方法 --->子类的初始化块--->子类的构造方法
  7. *
  8. * 对于静态的部分,按照声明的先后顺序进行加载
  9. *
  10. * @author 不落的太阳(Sean Yang)
  11. */
  12. class Parent1 {
  13. @SuppressWarnings("unused")
  14. private int x = 50;
  15. static {
  16. System.out.println("parent static block");
  17. }
  18. @SuppressWarnings("unused")
  19. private static int sx = getNext(99);
  20. {
  21. System.out.println("parant init block");
  22. }
  23. public Parent1() {
  24. System.out.println("parent constructor");
  25. }
  26. public static int getNext(int base) {
  27. System.out.println("static parameter initialized");
  28. return ++base;
  29. }
  30. }
  31. class Child1 extends Parent1 {
  32. static {
  33. System.out.println("child static block");
  34. }
  35. {
  36. System.out.println("child init block");
  37. }
  38. public Child1() {
  39. System.out.println("child constructor");
  40. }
  41. }
  42. public class LoadingOrder {
  43. public static void main(String[] args) {
  44. @SuppressWarnings("unused")
  45. Child1 child = new Child1();
  46. }
  47. }
/**
 * 类的加载顺序
 */
package org.sean.module03;

/**
 * 父类的静态代码块--->子类的静态代码块--->父类的初始化块 --->父类的构造方法 --->子类的初始化块--->子类的构造方法
 * 
 * 对于静态的部分,按照声明的先后顺序进行加载
 * 
 * @author 不落的太阳(Sean Yang)
 */
class Parent1 {

	@SuppressWarnings("unused")
	private int x = 50;

	static {
		System.out.println("parent static block");
	}

	@SuppressWarnings("unused")
	private static int sx = getNext(99);

	{
		System.out.println("parant init block");
	}

	public Parent1() {
		System.out.println("parent constructor");
	}

	public static int getNext(int base) {
		System.out.println("static parameter initialized");
		return ++base;
	}
}

class Child1 extends Parent1 {

	static {
		System.out.println("child static block");
	}

	{
		System.out.println("child init block");
	}

	public Child1() {
		System.out.println("child constructor");
	}
}

public class LoadingOrder {

	public static void main(String[] args) {
		@SuppressWarnings("unused")
		Child1 child = new Child1();
	}
}
分享到:
评论

相关推荐

    JAVA SE学习笔记

    **JAVA SE学习笔记** 在Java SE(标准版)的学习中,我们主要关注的是Java编程语言的基础和核心特性,包括但不限于语法、数据类型、控制结构、类与对象、接口、异常处理、多线程、集合框架、输入/输出(I/O)系统、...

    Java JDK 7学习笔记源代码

    《java jdk 7学习笔记》针对java se 7新功能全面改版,无论是章节架构或范例程序代码,都做了重新编写与全面翻新。并详细介绍了jvm、jre、java se api、jdk与ide之间的对照关系。必要时从java se api的源代码分析,...

    Java JDK7学习笔记-光盘

    《Java JDK7学习笔记》针对java se 7新功能全面改版,无论是章节架构或范例程序代码,都做了重新编写与全面翻新。并详细介绍了jvm、jre、java se api、jdk与ide之间的对照关系。必要时从java se api的源代码分析,...

    精品JAVA SE 学习笔记

    【Java SE学习笔记详解】 Java SE(Standard Edition)是Java平台的核心部分,它为开发桌面应用、服务器端应用以及中间件提供了基础。本笔记主要基于MLDN(Microsoft Learning Dynamic Network)李兴华老师的2009年...

    Java学习资料 java se JAVA基础学习笔记和演示案例代码项目

    "Java学习资料"这个压缩包显然包含了一些关于Java SE(标准版)的基础学习资源,包括笔记和实际的演示案例代码项目。Java SE是Java的核心部分,主要用于桌面应用和服务器端开发。 在Java的学习过程中,笔记通常会...

    java se个人学习笔记

    这份"java se个人学习笔记"显然是一份对Java SE基础知识的详细记录,由一位初学者整理,旨在帮助其他初学者理解这个强大的编程语言。笔记中可能涵盖了以下几个关键知识点: 1. **基础语法**:Java的基本数据类型、...

    Java+JDK+7学习笔记_林信良编著.pdf

    《Java JDK7学习笔记》针对java se 7新功能全面改版,无论是章节架构或范例程序代码,都做了重新编写与全面翻新。并详细介绍了jvm、jre、java se api、jdk与ide之间的对照关系。必要时从java se api的源代码分析,...

    非常详细javaSE学习笔记.rar

    Java SE(标准版)是Java开发平台的核心部分,它提供了编写、运行和部署桌面应用程序所需的类库和工具。这份“非常详细JavaSE学习...无论你是初学者还是有经验的开发者,这份详尽的Java SE学习笔记都是一个宝贵的资源。

    java se 1.8完整笔记,附大纲、代码、配图

    java SE 1.8笔记大纲 java SE 1.8是 Java 编程语言的标准版,本笔记涵盖了Java SE 1.8的所有知识点,从基本数据类型到...本笔记涵盖了 Java SE 1.8 的所有知识点,是一个非常完整和系统的 Java 编程语言学习资源。

    黑马java se视频笔记

    计算机基础知识是学习计算机科学和技术的基础,它...总结来说,了解计算机基础知识对于深入学习Java SE或其他计算机编程语言是十分必要的。它不仅为我们打下坚实的理论基础,还能帮助我们更好地理解和使用计算机技术。

    韩顺平编写的java学习笔记(全)

    ### 韩顺平编写的Java学习笔记概览 #### Java平台分类与运行机制 - **J2SE(Java 2 Platform, Standard Edition)**: 标准版Java开发平台,适用于桌面应用程序开发。 - **J2EE(Java 2 Platform, Enterprise ...

    JAVA SE 归档笔记

    【JAVA SE 归档笔记】是一份由多位IT行业高手共同编撰的珍贵资料,旨在为初学者提供学习指引,并作为经验丰富的开发者们的参考手册。这份笔记深入浅出地涵盖了JAVA SE(Java Standard Edition)的核心知识点,对于...

    Java学习笔记

    ●本书是作者多年来教学实践经验的总结,汇集了学员在学习课程或认证考试中遇到的概念、操作、应用等问题及解决方案, ●针对Java SE 8新功能全面改版,无论是章节架构或范例程序代码,都做了重新编写与全面翻新, ●...

    java学习笔记JDK6.0课件和代码

    这个压缩包中包含的"java学习笔记JDK6课件和课本代码"是学习JDK 6.0的重要参考资料,可以帮助你深入理解Java编程的核心概念和实践技巧。 1. **Java基础**:Java是一种面向对象的编程语言,它的基础包括类、对象、...

    java笔记本源代码

    此源代码使用Java SE(标准版)环境,可能涉及到Java的基础语法、类、对象、接口、异常处理、数据类型等。 2. **Swing库**:Java Swing库是用于构建GUI应用程序的组件集合。这个项目可能使用了JFrame、JButton、...

    JAVA-SE学习笔记

    这些基本概念构成了Java SE编程的基础,理解并掌握它们对于编写高效、可靠的Java代码至关重要。通过这些知识,开发者可以创建复杂的数据结构,实现灵活的设计模式,并构建出具有强大功能的应用程序。

    张龙 java se课程笔记

    1. **Java环境搭建**:首先,学习Java SE需要安装Java Development Kit (JDK),设置好环境变量`JAVA_HOME`、`PATH`和`CLASSPATH`,以便于编译和运行Java程序。 2. **Java语法基础**:Java是一种面向对象的语言,其...

Global site tag (gtag.js) - Google Analytics