第八章 Java面向对象

最新推荐文章于 2024-11-13 20:43:20 发布
最新推荐文章于 2024-11-13 20:43:20 发布
阅读量674 收藏
点赞数
文章标签： java 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l_1_0_O/article/details/116720702
版权

目录

构造器

概述

使用细节

总结属性赋值的过程

JavaBean

this关键字

概述

this调用属性

this调用构造器

this调用方法

继承

继承的使用

简单案例

继承性的再说明

Object类的理解

方法的重写

super关键字

概述

super调用属性和方法

super调用构造器

子类实例化的全过程

多态

虚拟方法的调用理解

构造器

概述

构造器，也称之为构造方法。（constructor）

构造器的作用：创建对象

说明：

1.  如果没有显示的定义了类的构造器的话，则系统默认提供一个空参的构造器

2.  定义构造器的格式：权限修饰符 类名(形参列表){}

public class Person {
	//属性
	String name;
	int age;
	
	public Person(){
		System.out.println("构造器执行了。。。");
	}
	
	//方法
	public void eat(){
		System.out.println("吃东西");
	}
}

public class PersonTest {
	public static void main(String[] args) {
		
		//创建类的对象：new + 构造器
		Person p1 = new Person();
		
		p1.eat();
	}
}

使用细节

构造器，也称为构造方法，constructor。

构造器的作用：

  1. 创建对象
  2. 初始化对象的信息

细节说明：

  1. 如果没有显式的定义类的构造器的话，则系统会默认提供一个空参的构造器
  2. 定义构造器的格式：权限修饰符 类名(参数列表){}
  3. 一个类中可以定义多个构造器，彼此构成重载
  4. 一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
  5. 一个类中至少会有一个构造器

总结属性赋值的过程

到目前为止，我们掌握的属性赋值的方式有：

  1. 默认初始化
  2. 显式初始化
  3. 构造器中初始化
  4. 通过“对象.方法”或者“对象.属性”的方式赋值

如果在一个类中用到了上面的赋值方式，那先后顺序是什么呢？ 就是上面写好的顺序。

public class UserTest {
	public static void main(String[] args) {
		User u1 = new User();
		u1.setAge(10);
		System.out.println(u1.getAge());
	}
}

class User{
	private String name;
	private int age = 1;
	
	public User(){
		age = 5;
	}
	
	public void setName(String n){
		name = n;
	}
	public String getName(){
		return name;
	}
	public void setAge(int a){
		age = a;
	}
	public int getAge(){
		return age;
	}
}

JavaBean

  1. JavaBean是一种Java语言写成的可重用组件
  2. 所谓JavaBean，是指符合如下标准的Java类：
    • 类是公共的
    • 有一个无参的公共构造器
    • 有属性，且有对应的get、set方法
/*
 * JavaBean
 */
public class Customer {
	private int id;
	private String name;
	
	public Customer(){
		
	}
	
	public void setId(int i){
		id = i;
	}
	
	public int getId(){
		return id;
	}
	
	public void setName(String n){
		name = n;
	}
	
	public String getName(){
		return name;
	}
}

this关键字

概述

  1. 在java中，this关键字比较难理解，它的作用和词义很接近
    • 它在方法内部使用，即这个方法所属对象的引用
    • 它在构造器内部使用，表示该构造器正在初始化的对象
  2. this表示当前对象，可以调用类的属性、方法和构造器
  3. 什么时候使用this？
    • 当在方法内需要用到调用该方法的对象时，就用this。具体的：我们可以用this来区分局部变量和属性。比如：this.name = name;

简单来说，this表示的就是当前这个对象。

this调用属性

public class User {
	private String name;
	private int age;
	
	public User(){
		
	}
	
	public User(String name, int age){
		//构造器中这个this表示的就是当前正在要创建的对象
		//这里的this就是为了区分局部变量和成员变量的
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		//这个this表示的就是 谁调用我这个方法，this就是谁！！！
		//这里的this就是为了区分局部变量和成员变量的
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
}

this调用构造器

public class Person {
	private String name;
	private int age;
	public Person() {
		
	}
	
	public Person(String name) {
		this.name = name;
	}

	public Person(String name, int age) {
		//这里的this是调用有一个String类型参数的构造器，且使用this调用构造器的话，
		//这行代码必须写在第一行！！！
		this(name);
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

this调用方法

public class Person {
	private String name;
	private int age;
	public Person() {
		
	}
	
	public void method1(){
		System.out.println("method1...");
		
		//这个this指的就是调用当前对象的method2方法，其实是可以省略的！
		this.method2();
	}
	
	public void method2(){
		System.out.println("method2...");
	}

继承

  1. 概述

现实生活中的继承是什么样的？有什么好处？

Java中的继承是什么样的？有什么好处？

 

可以发现继承的好处：

  1. 减少了代码的冗余，提高了代码的复用性
  2. 便于功能的扩展
  3. 为之后多态的使用提供了前提

继承的使用

  1. 继承的格式：class A extends B{ }

A：子类、派生类、subclass

B：父类、超类、基类、superclass

  1. 体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的结构：属性、方法。
  2. 特别地，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构，只是因为封装性的影响，使得子类不能直接调用父类的结构而已

子类继承父类以后，还可以声明自己特有的属性或方法，实现功能的扩展。子类和父类的关系，不同于子集和集合的关系。

简单案例

public class Person {
	
	private String name;
	private int age;
	public Person() {
		super();
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public void eat(){
		System.out.println("人吃饭！");
	}
	
	public void sleep(){
		System.out.println("人睡觉！");
	}
}

public class Teacher extends Person{

	private int teachAge;
	
	
	
	public int getTeachAge() {
		return teachAge;
	}


	public void setTeachAge(int teachAge) {
		this.teachAge = teachAge;
	}

	public void teach(){
		System.out.println("老师在讲课！");
	}
}

public class Student extends Person{

	private int score;

	public int getScore() {
		return score;
	}

	public void setScore(int score) {
		this.score = score;
	}
	
	public void study(){
		System.out.println("学生在学习!");
	}
}

public class Test {

	public static void main(String[] args) {
		
		Student student = new Student();
		
		//调用父类继承过来的方法
		student.eat();
		student.sleep();
		//调用自己的方法
		student.study();
		
		//调用父类继承的方法给属性设置值
		student.setName("张三");
		student.setAge(20);
		
		//调用自己的方法给属性赋值
		student.setScore(98);
	}
}

继承性的再说明

Java中继承性的规定：

1.  一个类可以被多个类继承

2.  Java中类的单继承性：一个类只能有一个父类

3.  子父类是相对的概念

4.  子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类

5.  子类继承父类以后，就获取了直接父类和所有间接父类中声明的属性和方法

通过案例演示上面的各个规定。

Object类的理解

定义一个Student类，创建一个Student类的对象s1，我们可以发现可以通过s1调用好多我们没有在Student类中写的方法，为什么呢？

  1. 如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类
  2. 所有的类(除java.lang.Object类之外)都直接或间接的继承于java.lang.Object类
  3. 意味着，所有的java类具有java.lang.Object类中声明的功能

方法的重写

  1. 定义：在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。
  2. 要求：
    • 子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
    • 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
    • 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限
      1. 子类不能重写父类中声明为private权限的方法
    • 子类方法抛出的异常不能大于父类被重写方法的异常

案例

public class Person {

	public void eat(){
		System.out.println("人吃东西！");
	}
}

public class Student extends Person{

	@Override
	public void eat() {
		System.out.println("学生喜欢吃零食！");
	}
}

public class Test {

	public static void main(String[] args) {
		
		Student student = new Student();
		student.eat();
	}
}

特殊地，如果父类中有两个方法A和B，其中A方法中调用了B方法，但是子类中重写了B方法，当我们创建子类对象后，调用A方法，这时候A方法中调用的B实际上是子类重写后的B方法。

super关键字

概述

super是超或者父的意思，使用super就可以调用父类中的属性、方法、构造器。

super调用属性和方法

使用super关键字可以在子类中调用父类的属性和方法

public class Person {
	private String name;
	private int age;
	int id = 123456;
	
	public Person() {
		
	}
	public Person(String name, int age, int id) {
		this.name = name;
		this.age = age;
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	
	public void eat(){
		System.out.println("人吃东西！");
	}
	
	public void run(){
		System.out.println("人在跑步！");
	}
}

public class Student extends Person{

	int id = 1001;
	
	public void showId(){
		System.out.println("id = " + id);
		//使用super调用父类中的属性
		System.out.println("super.id = " + super.id);
	}
	
	@Override
	public void eat() {
		System.out.println("学生吃零食！");
		
		super.eat(); //使用super调用父类中的方法
	}
}

public class Test {
	
	public static void main(String[] args) {
		
		Student student = new Student();
		student.showId();
		
		student.eat();
	}
}

super调用构造器

  1. 我们可以在子类的构造器中显式的使用super()调用父类的构造器
  2. super()必须在方法的首行
  3. 之前this()调用构造器也必须在首行，所以this()和super()是二选一的
  4. 在构造器的首行，如果没有显式的写this()或者super()，则默认调用父类的空参构造器，也就是默认是super()
public class Person {
	private String name;
	private int age;
	
	public Person() {
		
	}
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

public class Student extends Person{
	
	private String major;

	public Student() {
		//这里默认其实是 super()
	}

	public Student(String name, int age, String major) {
		//调用父类中的构造器
		super(name, age);
		this.major = major;
	}

	public String getMajor() {
		return major;
	}

	public void setMajor(String major) {
		this.major = major;
	}
}

public class Test {
	public static void main(String[] args) {
		
		Student student = new Student("张三", 25, "软件工程");
	}
}

子类实例化的全过程

子类对象实例化的全过程：

  1. 从结果上来看：（继承性）
    • 子类继承父类以后，就获取了父类中声明的属性和方法
    • 创建子类的对象，在堆空间中，就会加载所有父类中声明的属性
  2. 从过程上来看：
    • 当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器，直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有父类的结构，子类对象才可以考虑进行调用。

明确：虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建了一个对象，即为new的子类对象。（其实我们只是在子类中调用了父类构造器，并不是new 父类构造器() ）

其实也就是说，当我们创建一个子类对象的时候，它会从最顶级的父类一级一级的往下走，最后走的才会走完它自己的构造器。

多态

  1. 多态是面向对象语言的特征
  2. 多态：也就是一个事物的多种形态
  3. Java中的多态：父类的引用指向子类的对象
  4. 多态的使用：虚拟方法调用，也就是说：有了对象的多态性后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。

总结：编译，看左边；运行，看右边

  1. 多态的使用前提：1. 类的继承   2. 方法的重写

注意：属性是不存在覆盖之说的，对象的多态性只适用于方法，不适用于属性。

案例：

public class Person {
	private String name;

	public Person() {
		super();
	}

	public Person(String name) {
		super();
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	public void eat(){
		System.out.println("人在吃东西！");
	}
	
	public void run(){
		System.out.println("人在跑步！");
	}
}

public class Student extends Person{
	private int score;

	public Student() {
		super();
	}

	public Student(String name, int score) {
		super(name);
		this.score = score;
	}

	public int getScore() {
		return score;
	}

	public void setScore(int score) {
		this.score = score;
	}
	
	//重写父类的方法
	@Override
	public void eat() {
		System.out.println("学生在吃东西！");
	}
	
	//重写父类的方法
	@Override
	public void run() {
		System.out.println("学生在跑步！");
	}
}

public class Teacher extends Person{

	private int teachAge;

	public Teacher() {
		super();
	}

	public Teacher(String name, int teachAge) {
		super(name);
		this.teachAge = teachAge;
	}

	public int getTeachAge() {
		return teachAge;
	}

	public void setTeachAge(int teachAge) {
		this.teachAge = teachAge;
	}
	
	//重写父类的方法
	@Override
	public void eat() {
		System.out.println("老师在吃东西！");
	}
	
	//重写父类的方法
	@Override
	public void run() {
		System.out.println("老师在跑步！");
	}
}

public class Test {
	
//	public void method(Student student){
//		student.eat();
//		student.run();
//	}
//	
//	public void method(Teacher teacher){
//		teacher.eat();
//		teacher.run();
//	}
	
	public void method(Person person){
		//这里就用到了多态，具体person这个引用是指向哪个子类对象，
		//那这里就调用哪个子类的方法
		person.eat();
		person.run();
	}
	
	public static void main(String[] args) {
		Test test = new Test();
		
		test.method(new Student());
		
		test.method(new Teacher());
	}
}

虚拟方法的调用理解

  • 正常的方法调用
Person p = new Person();
p.getInfo();
Student s = new Student();
s.getInfo();
  • 虚拟方法调用(多态情况下)

子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。

Person p = new Student();

p.getInfo(); //调用Student类的getInfo()方法

  • 编译时类型和运行时类型

编译时p为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类的getInfo()方法。---动态绑定

小雷君
关注
java面向对象ppt_java面向对象课件
weixin_28930859的博客
02-12 932
PPT内容这是java面向对象课件，包括了类和对象的关系，构造方法，对象创建的内存模型，Java中的关键字等内容，欢迎点击下载。第三章 面向对象基础本章要点类和对象的关系面向对象的思想子类实例化的过程对象的创建构造方法变量的初始化顺序对象创建的内存模型垃圾回收机制Java中的关键字this关键字static关键字主要内容类和对象的关系面向对象的思想( Object Oriented Prog...
8.java学习第八章——面向对象.pdf
01-20
Java 学习第八章——面向对象 #### 面向过程与面向对象的区别 在讨论面向过程和面向对象之前，我们先明确几个概念。编程语言根据其编程范式可以分为多种类型，其中面向过程和面向对象是最常见的两种。 **面向...
Java面向对象
qq_55673797的博客
08-09 173
面向对象基础，封装继承多态，super,instanceof,static
Java类和对象（二）
m0_65683419的博客
11-14 677
面对对象程序三大特性：封装、继承、多态。🌹基本规则：1.在文件的最上方加上一个package语句指定该代码在哪个包中2.包名需要尽量指定成唯一的名字，通常会用公司的域名的颠倒形式3.包名要和代码路径相匹配，例如创建com.baidu.www的包，那么会存在一个对象的路径com/baidu/www来存储代码4.如果一个类没有package语句，则该类被放在一个默认包中src相当于是java中默认的包。🍓🍓操作步骤。
3.29作业
xiaolixiaozhou的博客
03-30 357
package com.qiku.day21; import java.io.Serializable; import java.util.Objects; public class Student implements Serializable { //1、定义学生类Student ，属性：姓名，学号，年龄，成绩 //提供：无参和全参构造器，生成get和set方法，重写toString ，equals ,hashCode //使用全参构造器创建3个学生对象，放入集合中 .
设计一个学生类 Student 包含姓名、成绩两个属性。定义一个无参的构造方法和一个接收两个参数的构造方法。
热门推荐
烟敛寒林的博客
12-08 6万+
请按照以下要求设计一个学生类 Student，并进行测试。 要求如下： Student 类中包含姓名、成绩两个属性 分别给这两个属性定义两个方法，一个方法用于设置值，另一个方法用于获取值. Student 类中定义一个无参的构造方法和一个接收两个参数的构造方法，两个参数分别为姓名和 成绩属性赋值 在测试类中创建两个 Student 对象，一个使用无参的构造方法，然后调用方法给姓名和...
Java面向对象（知识点整理）
yang642019851的博客
02-22 6万+
文章目录面向对象类与对象匿名对象创建对象的内存分析栈(stack)堆(heap)方法区PC寄存器本地方法栈内部类成员内部类局部内部类匿名内部类静态内部类包装类拆箱和装箱操作字符串转换基本数据类型和包装类型的区别Integer类型的重点抽象类抽象方法不能被实例化常见问题抽象类和普通类的区别接口面向接口编程思想全局常量和抽象方法的简写接口的实现 implements接口的继承 extends接口与抽象类的区别多态多态的体现多态的使用：对象的类型转换InstanceofObject类Object的多态toStri
java面向对象
黎小小的博客
08-21 4万+
本文内容是根据毕晓东老师的视频教程总结而得。包括面向对象概念、类与对象的关系、封装、构造函数、this关键字、static关键字、单例设计模式、继承、多态、内部类、异常、包等java基础知识。 1、面向对象 面向对象是相对面向过程而言 面向对象和面向过程都是一种思想 面向过程强调的是功能、行为 面向对象：将功能封装进对象，强调具备了功能的对象 面向对象是基于面向过程的 面向过程例子： ...
Java面向对象第八章课后习题
weixin_44836619的博客
10-15 1111
1.Java常用类库有哪些？其基本功能是什么？ Java.lang提供Java语言最基础的类。 Java.util实用包包括日期类和集合类。 Java.awt抽象窗口工具包用来构建和管理应用程序的图形用户界面。 Java.applet包含用来实现运行于浏览器的applet和一些相关接口。 Java.text文本包提供各种文本或日期格式。 Java.io输入输出流包，包含了实现Java程序与操作系...
第5章-JAVA面向对象编程基础.ppt
11-21
JAVA面向对象编程基础 JAVA面向对象编程是面向对象编程语言的基础，包含定义类、创建类的实例对象、构造函数、访问控制修饰符、静态属性和静态方法等内容。 一、定义类 在JAVA中，定义类使用class关键字，语法...
java面向对象程序设计课程每章ppt（共15章+复习1章）.zip
03-26
第10章 static修饰符.pptx 第10章 枚举.pptx 第11章 异常和断言.pptx 第12章 JDK8中的日期.pptx 第12章 字符串、日期.pptx 第13章 容器和泛型.pptx 第14章 流与文件（1）....第8章 包装器类.pptx 第9章 内部类.pptx
Java面向对象程序设计+源代码+课后习题答案)
10-31
Java面向对象程序设计是计算机科学中的一个重要领域，它基于面向对象编程（OOP）的概念，是一种强大的编程范式。在Java中，OOP的核心概念包括类、对象、封装、继承、多态等。这本书"Java面向对象程序设计"由耿祥义和...
《Java面向对象程序设计》(第版)课后答案.docx
05-30
《Java面向对象程序设计》是一本深入探讨Java编程的书籍，尤其关注面向对象的概念和实践。课后答案提供了对书中理论知识和实践练习的解答，帮助读者巩固学习成果。 1. **Java创始人**：Java语言是由James Gosling...
Servlet的生命周期
最新发布
wyk的博客
11-13 976
Servlet 的生命周期包含四个主要阶段：加载与实例化、初始化、请求处理、销毁。开发者可以在这些生命周期方法中编写初始化、请求处理和资源清理的代码，确保 Web 应用程序的正常运行。
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 276
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
Java基础07
m0_74977981的博客
11-11 677
如图下图：每个case中都有一个break，如果没有这个break，就不会跳出case，直到遇见break为止。
1112--接口
kequanrrr的博客
11-12 385
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
SpringBoot(五)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 716
Rest请求处理
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值