稳稳当当学java之继承(10)

最新推荐文章于 2023-12-10 13:28:32 发布
最新推荐文章于 2023-12-10 13:28:32 发布
阅读量176 收藏 1
点赞数 1
分类专栏： 笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42405054/article/details/106568005
版权

第十二章 继承

1.作业回顾

1，定义一个Person类（name,age,sno）进行数据封装，age的年龄范围设置为0到130，使用getAge返回年龄。

//1，定义一个Person类（name,age,sno）进行数据封装，age的年龄范围设置为0到130，使用getAge返回年龄。
public class Person {
	private String name;
	private int age;
	private String sno;
	
	public Person(String name, int age, String sno) {
		super();
		this.name = name;
		this.sno = sno;
		if(age <= 0 || age >=130) {
			System.out.println("数据非法");
			return;
		}
		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) {
		if(age <= 0 || age >=130) {
			System.out.println("数据非法");
			return;
		}
		this.age = age;
	}
	public String getSno() {
		return sno;
	}
	public void setSno(String sno) {
		this.sno = sno;
	}
}


public class Day121 {
	public static void main(String[] args) {
		Person p = new Person("张三", 20, "20191101");
		System.out.println(p.getAge()); //20
		p.setAge(-20); //数据非法
		System.out.println(p.getAge()); //20
	}
}

2，编写类Triangle，声明private的两个属性：底边长base和高height，同时提供getter和setter，在 TriangleManager类中定义一个方法public static double getArea(Triangle t)计算三角形的面积，并在main方法中输出。

public class Triangle {
	//2，编写类Triangle，声明private的两个属性：底边长base和高height，同时提供getter和setter
	
	private double base;
	private double height;
	
	public Triangle(double base, double height) {
		super();
		this.base = base;
		this.height = height;
	}

	public double getBase() {
		return base;
	}

	public void setBase(double base) {
		this.base = base;
	}

	public double getHeight() {
		return height;
	}

	public void setHeight(double height) {
		this.height = height;
	}	
}

public class TriangleManager {
	//TriangleManager类中定义一个方法public static double getArea(Triangle t)计算三角形的面积，并在main方法中输出。
	
	public static double getArea(Triangle t) {
		return t.getBase() * t.getHeight();	
	}
	
	public static void main(String[] args) {
		Triangle tr = new Triangle(3.0, 2.0);
		double area = getArea(tr);
		System.out.println(area);
	}
}

2.成员变量的初始值

java中，局部变量( 形参、方法内定义的变量、代码块中定义的变量 )没有初始化不能使用。成员变量( 类变量 和 实例变量 )如果没有初始化会有默认值。

public class Day122 {
	public static void main(String[] args) {
		int i;
//		System.out.println(i); //编译错误，i没有被初始化
	}
}

class Foo{
	//成员变量包括 类变量 和 实例变量
	
	//类变量
	static byte b;
	//实例变量
	short s;
	char c;
	int i;
	long l;
	float f;
	double d;
	boolean bool;
	String str;
}
//java中一个类文件可以有多个类，但只能有一个public类
//public类的名称要与文件名相同
public class Day122 {
	public static void main(String[] args) {
		
//		int i; //局部变量
//		System.out.println(i); //编译错误，i没有被初始化
		
		Foo foo = new Foo();
		System.out.println(Foo.b); //0   类变量通过类名访问
		System.out.println(foo.s); //0   实例变量通过对象访问
		System.out.println(foo.c); //
		System.out.println(foo.i); //0
		System.out.println(foo.l); //0
		System.out.println(foo.f); //0.0
		System.out.println(foo.d); //0.0
		System.out.println(foo.bool); //false 
		//null表示它不引用任何对象
		System.out.println(foo.str); //null  String为引用类型，引用类型默认值为null
	}
}

3.对象初始化

java中对象的初始化有三种方式：

1.在变量声明时赋值，

2.使用构造器，

3.使用代码块。

class Bar{
	private String name = setDefaultName(); //声明变量的时候赋值
	private int age = 0; //声明变量的时候赋值
	//类变量
	//记录创建对象的个数
	public static int COUNT;
	
	//静态代码块
	//静态代码块在类被加载时执行
	//每个类只被加载一次，因此静态代码块只执行一次
	//静态代码块用来初始化静态字段（类变量）
	//不能访问实例字段（实例变量）
	static {
		COUNT = 0;
		System.out.println("1静态代码块执行");
	}
	
	//非静态代码块
	//非静态代码块在每次创建对象的时候执行
	//非静态代码块用来初始化实例字段（实例变量）
	{
		System.out.println("3非静态代码块执行");
		COUNT++;
	}
	
	public Bar() {
		System.out.println("4默认构造器执行");
	}
	
	private String setDefaultName() {
		System.out.println("2setDefaultName()");
		return "setDefaultName";
	}
	
	public Bar(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}	
}

public class Day123 {
	public static void main(String[] args) {
		//1.加载类，执行静态代码
		//2.执行成员变量的赋值语句
		//3.执行非静态代码块
		//4.调用构造器
		
		//ctrl + f查找和替换
		Bar bar1 = new Bar();
		System.out.println(bar1.getAge()); //0
		System.out.println(bar1.getName()); //setDefaultName
		System.out.println(Bar.COUNT); //1
		
		//2.执行成员变量的赋值语句
		//3.执行非静态代码块
		//4.调用构造器
		Bar bar2 = new Bar(); 
		System.out.println(bar2.getAge()); //0
		System.out.println(bar2.getName()); //setDefaultName
		System.out.println(Bar.COUNT); //1	
	}	
}

4.继承

java中通过继承一个类，来继承此类的所有功能。java中的每一个类都继承于Object类，当创建一个类时，会自动的继承Object类的所有方法。

//java中的所有类都继承于Object类
//类F继承于Object
class F{
	
}

public class Day124 {
	public static void main(String[] args) {
		//ctrl + shift + t 打开一种类型
		//Ctrl + o 打开类的列表信息（属性和方法）
		
		F f = new F();
		//toString方法继承于Object
		System.out.println(f.toString()); //day12.F@53bd815b
		
		//hashCode方法继承于Object
		//hashCode方法是本地方法，没有方法体
		//native方法会调用底层的c语言的函数
		//hashCode方法将返回对象的哈希码
		System.out.println(f.hashCode()); //1404928347
		
		//instanceof关键字用于判断一个对象是否是这个类型
		//f是F类的实例
		System.out.println(f instanceof F); //true
		
		//f是Object类的实例
		System.out.println(f instanceof Object); //true
		
		//动物（Object）
		//哺乳动物（F）
		//f是某一只具体的哺乳动物（我家的狗——小黑）
	}
}

Object类位于java.lang包中，它定义和实现了所有类的通用功能。在java中所有的类都继承于Object类。因此Object类是所有类的超类。

在这里插入图片描述

下面是继承的例子

//Person没有写继承，那么就自动继承Object类
class Person {
	String name;
	int age;

	public void info() {
		System.out.println("我叫" + name + ",我今年" + age + "岁了");
	}
}

// extends 关键字用来继承一个类
// Student类是Person的子类，Person类是Student类的父类
// Student类继承了Person类中定义的属性和方法
// Student类有三个属性，两个方法
class Student extends Person {
	// 学号
	int sno;

	public void study() {
		System.out.println("好好学习，天天向上");
	}
}

//Actor类继承于Person，一个父类可以有多个子类，一个子类只能有一个父类
class Actor extends Person {
	// 薪水
	double salary;

	public void act() {
		System.out.println("我热爱表演");
	}
}

public class Day125 {
	public static void main(String[] args) {
		Student s = new Student();
		//name和age属性继承于Person
		s.name = "小明";
		s.age = 10;
		//sno是Student类中定义的属性
		s.sno = 20191101;
		//info方法继承于Person
		s.info();
		//study方法是Student类中定义的方法
		s.study();
		
		Actor a = new Actor();
		//name和age属性继承于Person
		a.name = "梁朝伟";
		a.age = 50;
		//salary是Student类中定义的属性
		a.salary = 10000000;
		//info方法继承于Person
		a.info();
		//act方法是Student类中定义的方法
		a.act();	
	}
}

5.子类对象的实例化过程

子类对象创建之前必须先有父类对象 ，子类对象的构造器默认会调用父类的无参构造器，以便创建父类的对象。

class Person {
	String name;
	int age;
	
	public Person() {
		super(); //调用父类的无参构造器
		System.out.println("Person构造器");	
	}
	
	public void info() {
		System.out.println("我叫" + name + ",我今年" + age + "岁了");
	}
}

class Student extends Person {
	//学号
	int sno;
	
	public Student( int sno) {
		//子类对象创建之前必须先有父类对象
		//子类对象的构造器默认会调用父类的无参构造器，以便创建父类对象
		//super()调用父类的无参构造器
		super(); //写不写都一样，默认会调用父类的无参构造器
		System.out.println("Student构造器");
		this.sno = sno;
	}
	
	public void study() {
		System.out.println("好好学习，天天向上");
	}
}

public class Day126 {
	public static void main(String[] args) {
		Student s = new Student(20191101); //创建两个对象，父类对象和子类对象		
	}
}

在这里插入图片描述

上面的例子中，子类的属性被初始化，但是父类的属性没有被初始化。

有个两种方式可以解决父类的属性初始化。

第一种：在子类的构造器中直接初始化从父类继承的属性。

class Person {
	String name;
	int age;
	
	public Person() {
		super(); //调用父类的无参构造器
		System.out.println("Person构造器");	
	}
	
	public void info() {
		System.out.println("我叫" + name + ",我今年" + age + "岁了");
	}
}

class Student extends Person {
	//学号
	int sno;
	
	public Student(String name, int age, int sno) {
		//子类对象创建之前必须先有父类对象
		//子类对象的构造器默认会调用父类的无参构造器，以便创建父类对象
		//super()调用父类的无参构造器
		super(); //写不写都一样，默认会调用父类的无参构造器
		System.out.println("Student构造器");
		this.name = name;
		this.age = age;
		this.sno = sno;
	}
	
	public void study() {
		System.out.println("好好学习，天天向上");
	}
}

public class Day1261 {
	public static void main(String[] args) {
		Student s = new Student("小明", 10, 20190001); //创建两个对象，父类对象和子类对象	
		System.out.println(s.name); //张三
		System.out.println(s.age); //30
		System.out.println(s.sno); //20191101
	}
}

第二种：调用父类的有参构造器进行初始化。(推荐)

class Person4 {
	String name;
	int age;
	
	public Person4(String name, int age) {
		this.name = name;
		this.age = age;
		System.out.println("Person4构造器");	
	}
	
	public void info() {
		System.out.println("我叫" + name + ",我今年" + age + "岁了");
	}
}

class Student4 extends Person4 {
	//学号
	int sno;
	
	public Student4(String name, int age, int sno) {
        //调用父类的有参构造器，对name和age进行赋值
		super(name, age);
		this.sno = sno;
		System.out.println("Student构造器");
	}
	
	public void study() {
		System.out.println("好好学习，天天向上");
	}
}

public class Day1262 {
	public static void main(String[] args) {
		Student4 s = new Student4("小明", 10 , 20190001); //创建两个对象，父类对象和子类对象		
		System.out.println(s.name);
		System.out.println(s.age);
		System.out.println(s.sno);
	}
}

在这里插入图片描述

class Person5 {
	String name;
	int age;
	
	public Person5(String name, int age) {
		this.name = name;
		this.age = age;
		System.out.println("Person5构造器");	
	}
	
	public void info() {
		System.out.println("我叫" + name + ",我今年" + age + "岁了");
	}
}

class Student5 extends Person5 {
	//学号
	int sno;
	
	public Student5(String name, int age, int sno) {
		//调用父类的有参构造器，对name和age进行赋值
		super(name, age);
		this.sno = sno;
		System.out.println("Student构造器");
	}
	
	public void study() {
		System.out.println("好好学习，天天向上");
	}
}

public class Day1263 {
	public static void main(String[] args) {
		Student5 s1 = new Student5("张三", 30, 20191101); //创建两个对象，父类对象和子类对象		
		System.out.println(s1.name);
		System.out.println(s1.age);
		System.out.println(s1.sno);
		
		Student5 s2 = new Student5("李四", 10, 20191102); //创建两个对象，父类对象和子类对象		
		System.out.println(s2.name);
		System.out.println(s2.age);
		System.out.println(s2.sno);
		
		//一共四个对象
	}
}

6.继承的规则一

静态成员（静态变量，静态常量，静态方法）不考虑继承问题，静态成员不能被继承。

子类不能继承父类的private 成员（属性和方法）。

protected成员包括包访问权限，protected成员可以被同一个包下的所有类访问。

protected成员可以被子类访问，不管这个子类和父类是否在同一个包下。

子类可以继承对它可见的成员。

子类可以继承父类的public，protected成员。

如果子类和父类在同一个包下，子类还可以继承父类的default成员。

构造器不是类的成员，因此无法被继承，但是子类可以使用super关键字调用其超类的构造器。 子类可以声明和超类同名的字段，这将导致隐藏其超类的字段。

class Person6 {
	String name;

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

class Student6 extends Person6{
	//子类的将隐藏超类的同名字段
	private String name;
	private int sno;
	
	public Student6(String name1, String name2, int sno) {
		super(name1);
		//访问的是子类的name
		name = name2;
		this.sno = sno;
	}
	
	public void showInfo() {
		//super代表父类的对象
		System.out.println("父类对象的名字:" + super.name);
		System.out.println("子类对象的名字:" + this.name);
		//访问的是子类的name
		System.out.println("我的名字:" + name + "我的学号" + sno);
	}	
}

public class Day127 {
	public static void main(String[] args) {
		Student6 s = new Student6("1", "2", 20191101);
		s.showInfo(); 	//父类对象的名字:1
						//子类对象的名字:2
						//我的名字:2我的学号20191101
	}	
}

7.练习

1，编写一个Person类，包括属性（name、age），有参构造器、方法say(返回自我介绍的字符串）。

2.编写一个 Student类，继承Person类，增加sno、score属性，以及有参构造器，在子类中调用父类的构造器。

3.编写一个方法showInfo(返回自我介绍的字符串）。

十年之伴
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
定义一个Person类，包含私有属性name、age，getXxx和setXxx方法和有参满参构造方法。
weixin_52067329的博客
04-05 1万+
定义一个Person类，包含私有属性name、age，getXxx和setXxx方法和有参满参构造方法。 使用反射的方式创建一个实例、调用构造函数初始化name、age。使用反射方式调用setName方法对姓名进行设置，不使用setAge方法直接使用反射方式对age赋值。 public class Person { private int age; private String name; public Person() { } public Person(.
python基础 Day9
m0_55514551的博客
08-16 435
文章目录1、Python中new方法作用是什么？2、什么是单例模式？单例模式适用于什么场景？3、私有化方法与私有化属性在子类中能否继承？4、在Python中什么是异常？5、Python中是如何处理异常的。6、Python中异常处理语句的一般格式，可以使用伪代码的形式描述。7、__slots__属性的作用8、私有化属性的作用？9、在类外面是否能修改私有属性。10、如果一个类中，只有指定的属性或者方法能被外部修改。那么该如何限制外部修改。1、编写一段代码以完成下面的要求2、请写一个单例模式3、创建一个类，并定义
编写一个java程序，在程序中定义一个person类，其中age属性是一个私有属性，并且范围为5~20。
王陈锋的博客
08-05 4242
class person { String name; private int age; public boolean setage(int newage) { if(newage>=5&&newage<=20) { age=newage; return true; } else return false; } publ.
Python3 对象私有属性和私有方法总结
zhouzhiwengang的专栏
08-13 637
应用场景： 在实际开发中，对象的某些属性或方法可能只希望在对象的内部被使用，而不希望在外部被访问到 私有属性就是对象不希望公开的属性 私有方法就是对象不希望公开的方法 定义方式： 在定义属性或方法时，在属性名或者方法名前增加两个下划线，定义的就是私有属性或方法 eg: 定义model.py 文件，核心代码如下 # 定义Person 类,包含对象属性name 和对象私有属性 age 和对象私有方法 class Person: def __init__(...
parseInt()把字符转换成数字型 转化成整数
weixin_58414196的博客
04-07 631
// 1.parseInt把字符转换成数字型 转化成整数 var age = prompt('请输入你的年龄'); console.log(age); console.log(parseInt(age)); console.log(parseInt('9.94')); console.log(parseInt('200px')); // 2.parseFloat 把字符转换成小数 转化成浮点数 console.log(parseFloat('9.123')); //3.Number() /
python中私有属性的使用
每天都要进步的博客
08-11 762
私有属性 python对类的成员没有严格的访问控制限制，这与其他面向对象语言有区别。关于私有属性和私有方法，有如下要点： 1.通常我们约定，两个下划线开头的属性是私有的（private）。其他的为公共的（public)。 2.类内部可以方位私有属性(方法) 3.类外部不能直接访问私有属性(方法) 4.类外部可以通过“_类名__私有属性(方法)名”访问私有属(方法) 【注】方法本质上也是属性！只不过是可以通过()执行而已。所以，此处讲的私有属性和公有属性，也同时讲解了私有方法和公有方法的用法。如下测试中，同时
Python面向对象编程基础
互联说
03-20 243
本文介绍了Python中的面向对象编程基础，包括类和对象、继承和多态、封装等。面向对象编程是一种非常强大的编程思想，它可以帮助我们更好地组织和管理代码，提高代码的复用性和可维护性。希望本文能对初学者有所帮助，更深入地理解和应用面向对象编程思想。
稳稳当当学java之数组(7)
06-01
本人的笔记，关于Java基础中数组的内容 包括 1.作业回顾 2.数组的概念 3.创建，初始化，和访问数组 4.遍历数组 5.基本数据类型和引用数据类型的区别 6.使用Arrays类 7练习
稳稳当当学java之方法(6).md
05-29
本人的笔记，关于Java基础中方法的内容。 包括 1.作业回顾 2.方法的定义 3.向方法传递参数 4.方法返回值 5.方法重载 6.变量的作用域 7.使用类常量和类方法 8.练习
稳稳当当学java之面向对象编程(8)
06-02
本人的笔记，关于java基础中面向对象编程的内容 包括 1.作业回顾 2.类和对象 3.实例方法 4.成员变量 5.练习
稳稳当当学java之循环(5).md
05-29
本人的笔记，关于Java基础中循环的内容 包括 1.作业回顾 2.while 循环 3.do while 循环 4.for 循环 5.break语句 6.continue 语句 7.练习
面向对象(下)
qq_45780540的博客
09-11 394
目录 私有化属性 私有化方法 Property属性 new实例化方法 单例模式 错误和异常处理 自定义异常 动态添加属性和方法 slots属性限制 作业 私有化属性 加两个下划线将此属性私有化 使用私有属性的场景 1.把特点的一个属性隐藏起来，不想让类的外部进行直接调用 2.我想保护这个属性，不想让属性的值随意改变 3.保护这个属性，不想让子类去继承 class Person: __hobby='跳舞' def __init__(self): .
自学python所记（十一）
weixin_53954406的博客
05-03 1093
案例二：封装 需求： 类名：房子类House 属性：户型 name , 总面积 area , 剩余面积free_area,家具名称列表item_list 方法：__init__ ,__str__ 添加家具方法 def add_item(self,item): # item 家具对象 先判断房子的剩余面积和总面积的关系 修改房子的剩余面积 修改房子的家具列表名称 类名： 家具类HouseItem 属性：名字name , 占地面积area 方法：__init__ ,__str__ # 定义家具
十三、 封装、继承和多态
CaesarQu的博客
05-30 6858
第1关：什么是封装，如何使用封装 任务描述 本关任务：构造一个类，把对象的属性封装起来，同时提供一些可以被外界访问属性的方法。 相关知识 为了完成本关任务，你需要掌握：1.什么是封装；2.封装的意义；3.实现Java封装的步骤。 什么是封装 封装：就是隐藏对象的属性和实现细节，仅对外提供公共访问方式。 封装时的权限控制符区别如下: 封装的意义 对于封装而言，一个对象它所封装的是自己的属性和方法，所以它是不需要依赖其他对象就可以完成自己的操作。使用封装有四大好处： 良好的封装能够减少耦合。 ...
Python类的属性和方法
相信相信的力量
08-26 321
Python类是一种面向对象编程的基本概念，它可以用来创建对象，对象可以拥有属性和方法。属性是类的特征，它们用于存储对象的状态。属性可以是任何数据类型，例如整数、字符串、列表等。在类中，属性通常定义为类的变量，并在类的方法中使用。方法是类的行为，它们用于定义对象的操作。方法是类中的函数，它们可以访问和操作类的属性。方法可以被调用来执行特定的任务。下面是一个简单的示例，展示了一个名为Person的类...
c++设计一个person类封装name和age属性
最新发布
jj56911的博客
12-10 800
设计一个 Person类，Person类具有name和 age属性，提供初始化函数(Init)，并提供对name和 age 的读写函数(set , get)，但必须确保 age的赋值在有效范围内(0-100),超出有效范围,则拒绝赋值，并提供方法输出姓名和年龄。首先检查年龄是否在有效范围（0到100之间），如果是，则设置年龄和姓名，否则将年龄设为默认值并输出错误消息。这段代码实现了一个简单的 Person 类，该类具有姓名（m_name）和年龄（m_age）属性。get_age函数：返回对象的年龄。
Java笔记之面向对象 中（八）
weixin_44604159的博客
04-22 174
封装、继承、super、this以及方法的重写和重载
Java学习——第三章 第四章
~陈宇轩轩轩轩~
08-02 1402
第三章 面向对象编程 3.9关键字——this 1.什么是this 含义： 1.在方法内部使用，即这个方法所属对象的引用 ​ 2.在构造器内部使用，表示该构造器正在初始化的对象 this 表示当前对象，可以调用类的属性、方法和构造器 当在方法内部需要用到该方法的对象时，使用this 2.使用this，调用属性、方法 package 基础02; public class Person1 { public Person1() { } public Person1(
JAVA 面向对象基础知识
qq_53881918的博客
05-28 1938
对象与引用 首先定义一个Person类，它有name和age两个属性。 public class Person { private String name; private int age; public Person(String name, int age){ this.name =name; this.age = age; } } 创建一个对象： Person p1 = new Person(

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

十年之伴

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值