Java SE基础6-（继承、super、抽象、重写）

最新推荐文章于 2023-06-23 12:30:00 发布
最新推荐文章于 2023-06-23 12:30:00 发布
阅读量202 收藏
点赞数
分类专栏： javaSE 文章标签： java 抽象类 多态
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangbo_CSDN/article/details/114855693
版权

飞机大战分析:

对象提取类:小敌机/大敌机/自己的飞机/子弹/小蜜蜂

小敌机类:
  成员变量:
  	int x,int y,图片,int width
  	int height, 
  成员方法:
  	move()
大敌机类:
	成员变量:
	int x,int y, 图片,int width
  	int height ,  int life
  	成员方法:
  	move()
自己的飞机类:
	int x,int y, 图片,int width
  	int height , int life,int score,子弹
  	成员方法:
  	move()
子弹类:
	int x,int y, 图片,int width
  	int height
  	成员方法:
  	move()
小蜜蜂类:
	int x,int y, 图片,int width
  	int height
  	成员方法:
  	move()

把所有类中相同的成员变量和成员方法 -> 提取出来 -> 形成一个类 -> 父类

升级版:
子类 extends 父类

父类(基类):
  成员变量:
    int x,int y, 图片,int width
  	int height
  成员方法:
  	move()
子类(衍生类/扩展类):
  小敌机类:
  大敌机类:
  	int life
  自己的飞机类:
  	int life,子弹,int score
  子弹类:
  小蜜蜂类:

1.继承(extends)

1.结构:
子类(衍生类/扩展类) extends 父类/基类
2.继承的特征:
1)子类继承父类,会继承父类中所有的成员变量和成员方法
2)所有的类,都有唯一的父类
如果没有写父类,那么就会默认继承Object
3)子类可以拥有自己独有的成员变量和成员方法
并且,子类的功能一定会比父类的更强大
4)一个类只能继承一个父类,但是一个父类可以有很多个子类

特殊情况:

1.创建子类对象之前,会先创建父类对象
	加载子类之前会先加载父类
2.构造方法:
	调用子类构造方法之前,一定会调用父类的构造方法,默认调用父类的无参构造方法
3.子类中可以引用父类对象
4.子类和父类中有相同的成员变量时
	例如: name
	那么会先去运行子类中成员变量,如果没有才会去找父类中的成员变量

	建议:子类和父类中不要有相同的成员变量
5.通过子类对象调用方法时
	会先去找子类中有没有这个方法,如果有就实现子类中的内容
	如果没有,就会往上去找父类中的方法

2.super关键词:父类对象

1)调用子类构造方法之前,一定会调用父类的构造方法,默认调用父类的无参构造方法
使用super关键词调用
2)父类中的构造方法只能调用,不能继承,默认添加super()
3)如果父类中没有无参构造方法,就需要手动调用父类中的有参构造方法
super(参数)
4)super(参数),只能放在构造方法的第一行

3.方法的重写

1)重写的前提:
	必须存在父子类关系
2)语法结构:
	子类中定义的方法的方法名+方法参数+返回值类型都必须和父类中完全一致

方法的重写(Override)和方法的重载(Overload)的区别:
	方法的重写的前提:
		必须在父子类关系中
	方法的重载的前提:
		必须在同一个类中
		参数不一样:
			个数
			顺序
			类型

this和super的区别:

4.抽象(abstract) abstract可以修饰: 修饰类/方法

1)抽象方法:
a.出现的前提:
例如:move()
所有的子类中的move()都有不同的实现,那也就是说明父类中的move()方法体没有意义
没有意义的东西不需要 -> 删除 -> 抽象方法 -> 加abstract
b.子类必须重写父类中的抽象方法
如果不重写,就要把自己变成抽象类
c.抽象方法的特点
1.没有方法体的方法叫抽象方法
2.抽象方法一定要存在于抽象类中

2)抽象类
a.abstract修饰的类叫抽象类
b.抽象类不能new对象,也就是不能创建类的实例化
c.抽象类也有构造方法,就是为了给子类使用的

3)abstract不能修饰成员变量,因为成员变量是有具体的类型

判断:

有抽象方法的类就是抽象类 √
抽象类就是有抽象方法的类 ×
没有抽象方法的也是抽象类 √

5.访问修饰符/权限控制符

public:公开的,公共的
protected:受保护的
default:默认的,(default)是不写的,没有的这个词
private:私有的

访问控制符可以修饰:修饰类/修饰[静态]成员变量/修饰[静态]成员方法/代码块/构造方法

自己类中: 所有的访问修饰符都可用
同包(没有任何关系的类): public default protected
不同包下(有父子关系的类): public protected
所有类(不同包下没有任何关系的类):public

访问权限的范围:
最大的是public,最小的是private

使用情况:
public:想让所有的类都可见时
protected:在父子类关系中可用
default:不常用,练习时使用
private:普通类中都可用
get/set调用

eg1：
abstrctclass包
package abstractclass;
/*
小敌机
*/
public class AirPlane extends FiyingObject{

@Override
void move() {
    System.out.println("这是小敌机的移动方法");
}

@Override
void m1() {

}

@Override
void m2() {

}

}

package abstractclass;
/*
小蜜蜂
*/
public class Bee extends FiyingObject{
@Override
void move() {
System.out.println(“这是小蜜蜂的移动方法”);
}

@Override
void m1() {

}

@Override
void m2() {

}

}

package abstractclass;
/*
父类 - 飞行物类

*/
public abstract class FiyingObject {
//成员变量
/abstract/ int x;
int y;

//构造方法 - 为了给子类使用
FiyingObject(){

}
FiyingObject(int x){

}

//成员方法 - 移动的方法
//去掉方法体 -> 抽象方法 -> 加abstract
//所有子类中相同的方法 -> 为了子类代码的统一
abstract void move();
abstract void m1();
abstract void m2();


void m3(){
    System.out.println("这是抽象类中的普通方法");
}

}

package abstractclass;
/*
自己的飞机类
*/
public /abstract/ class Hero extends FiyingObject{
@Override
void move() {

}

@Override
void m1() {

}

@Override
void m2() {

}
/*@Override
void move() {
    System.out.println("这是自己的飞机类的方法");
}*/

}

package abstractclass;
/*
测试类
*/
public class Demo01Abstract {
public static void main(String[] args) {
//创建抽象类的对象 - 抽象类不能new 对象
//FiyingObject fiy = new FiyingObject();
Bee bee = new Bee();
bee.move();
bee.x = 1;
bee.y = 2;

    Hero hero = new Hero();
    hero.move();
}

}

eg2:
sub包
package sub;
/*
动物类 - 父类
*/
public class Animal extends Object{
//成员变量
int age;
int weith;
int height;
String name;

//无参构造方法

Animal(){
System.out.println(“Animal的无参构造方法”);
}
//有参构造方法
Animal(String name){
this.name = name;
System.out.println(“Animal的有参构造方法”);
}

//成员方法
String eat(String name){
    System.out.println(this.name + "在吃东西");
    System.out.println(this.name + "在吃东西");
    System.out.println(this.name + "在吃东西");
    System.out.println(this.name + "在吃东西");
    System.out.println(this.name + "在吃东西");
    System.out.println(this.name + "在吃东西");

    return null;
}

}

package sub;
/*
小猫类 - 子类
1.子类之间本质上没有任何关系
2.唯一关系就是拥有共同的父类
/
public class Cat/ extends Animal*/{

}

package sub;
/*
小狗类 - 子类
1.子类继承父类,会继承父类中所有的成员变量和成员方法
2.所有的类,都有唯一的父类
如果没有写父类,那么就会默认继承Object
3.子类可以拥有自己独有的成员变量和成员方法
并且,子类的功能 一定会比父类的更强大
4.父类可以有很多个子类
*/
public class Dog extends Animal{
//自己的成员变量
char sex;
String name;

//无参构造方法
Dog(){
    this("");
    //super("小黑");
    //super();调用父类的无参构造方法
    System.out.println("Dog的无参构造方法");
}
Dog(String name){
    //调用父类的有参构造方法
    super("小黑");
    //super();
    //super:父类对象
    //super.name = name;
    this.name = name;
    System.out.println("Dog的有参构造方法");

}

//自己的成员方法
void wang(){
    System.out.println("小狗在叫!!!");
}

//跟父类中相同的成员方法

/String eat(String name){
// System.out.println(this.name + “在吃东西”);
System.out.println(this.name + “在吃东西”);
System.out.println(this.name + “在吃东西”);
System.out.println(this.name + “在吃东西”);
System.out.println(this.name + “在吃东西”);
System.out.println(this.name + “在吃东西”);//*
// System.out.println(this.name + “在吃东西”);//
super.eat(“小黑”);
//super.age = 21;
System.out.println(“吃完了,还吃”);
System.out.println(“继续吃”);
return null;
}*/

//重写的快捷键   Ctrl+o  Alt+Ins
@Override
String eat(String name) {
    return null;
}

}

package sub;
/*
测试类 - 只放主方法
*/
public class Demo01Test {
public static void main(String[] args) {
//创建小狗类的对象
Dog dog = new Dog();
//dog.name = “旺财”;
dog.age = 12;
//调用子类中的成员方法 - 继承
dog.eat(“小黑”);
System.out.println(dog.name);
dog.eat(“小黑”);

    //属于Object的方法,所以可以直接调用
    //dog.hashCode();
}

}

eg3：
visit包
package visit.child;

import visit.Animal;

/*
不同包下,并且没有任何关系的类 - 和Animal
/
public class Demo02Test {
public static void main(String[] args) {
//创建Animal类的对象
Animal a = new Animal();
System.out.println(“a_public:” + a.a_public);
/ System.out.println(“b_protecte:” + a.b_protecte);
System.out.println(“c_default:” + a.c_default);
System.out.println(“d_private:” + a.d_private);*/
}
}

package visit.child;

import visit.Animal;

/*
有父子类关系的类
*/
public class Dog extends Animal {

//使用 Animal类中的成员变量
public void m2(){
    System.out.println("a_public:" + a_public);
    //protected -> 修饰有父子类关系的类
    System.out.println("b_protected:" + b_protecte);
    //System.out.println("c_default:" + c_default);
    //System.out.println("d_private:" + d_private);
}

}

天 阳 在 线€
关注
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Java封装、继承、多态、super杂糅在一起的小练习，公司雇员员工工资问题（Employee），练习扩展：创建一个Employee数组，分别创建不同的Employee对象，并打印某个月的工资
奈何的人生
02-21 3117
下面分为三种打印方法： import java.util.Scanner; /** * @author Ziph * @date 2020年2月21日 * @Email mylifes1110@163.com */ public class TestDemo { public static void main(String[] args) { //------------------...
关于Java中this ,super ,return的用法分享
m0_58673188的博客
09-18 1056
1、this关键字 this关键字指向对象本身,一个类可以通i过this来获得一个代表它自身的对象变量.this使用在如下三种情况中; 调用实例变量. 调用实例方法. 调用其他构造方法. this变量实例代码. public class Person { private String name; private int age; private Date birthDate; public Person(String name,int age,Date d) { this n.
当继承遇到self和super
czttcztt的博客
07-02 483
本文主要是在研究python在继承中，当使用super()调用父类方法后，其方法中的self到底指代谁这一问题过程中进行的总结，基本结论就是self指代的是子类实例，即向父类方法传递子类实例。
python中的super()用法以及多继承协同任务
Yonx
09-16 2577
理解了python的MRO之后，我们就可以更加准确地使用super()函数，以及使用super()完成多继承协同任务 super().method()是调用父类中的方法，这个搜索顺序当然是按照MRO从前向后开始进行的 super([type][, object-or-type]) 根据官方文档，super函数返回一个委托类type的父类或者兄弟类方法调用的代理对象。super函数用来调用已经在子类中重写过的父类方法。 这句话其实很难看明白，为什么除了父类还可能是兄弟类? 要理解这句话，先谈谈su..
Python 中的 super参数
最新发布
迹忆客
06-23 1463
本文的主题是正确使用 Python 超级参数。我们还将了解超和继承的概念、使用超参数的适当代码示例以及基类的概念。
Java SE基础知识：继承、抽象与多态
"该文档是关于Java SE基础知识的总结，涵盖了继承、抽象类与接口、多态、权限修饰符、代码块、Object类、Date类、DateFormat类、Calendar类、Math类、System类、BigDecimal类、Arrays类以及包装类的相关知识。...
Java SE编程入门教程 java封装继承多态（共56页）.pptx
12-04
在Java中，`extends`关键字用于实现继承，多态则通过方法重写和抽象类/接口来实现。 3. **类和对象**：类是对象的蓝图，它定义了对象的属性（变量）和行为（方法）。对象是类的实例，具有类定义的属性和方法。Java...
Java SE 面向对象：继承、多态与抽象概念详解
通过以上内容的学习，你可以深入理解Java面向对象编程的基础，并掌握如何利用继承、多态性和抽象类等机制构建更加灵活和可维护的程序。同时，对Object类和代码块的理解有助于更好地设计和组织代码结构。
Java SE基础笔记：类、对象、继承与重载详解
Java SE笔记涵盖了Java编程语言的基础概念和核心特性，对于理解和实践Java编程至关重要。以下是笔记中的关键知识点： 1. **类与对象**: - 类是抽象的蓝图，它是创建对象的模板，对象则是类的具体实例。 - 类包含...
JAVA SE中 X++ 跟 ++X 的区别
TinyTroopers
11-12 3471
在实现x递增加1操作时, x++和++x有什么区别？ 我们先看下面这段代码： //区别 x++ 跟 ++x 的区别 public class Practise1 {     public static void  main(String[] args){         int x=1;         int y=x++;                  System.out.
react中super()的理解
zhengzhengwang的专栏
08-20 1197
es6 class(类) 方法创建组件 1 // 构造函数 会 默认生成 一个原型对象 2 function Person(name,) { 3 this.name = name; 4 } 5 console.log(Person); // 构造函数本身 6 console.log(Person.prototype） // 指向原型对象 7 console.log(Pers
return super.color;
autumn20080101的专栏
01-01 1041
class Grandfather { String color= "Grandfather颜色"; } class Father extends Grandfather { //String color= "Father颜色"; } class Son extends Father { String color= "Son颜色"; String getSuperColor() {
使用return结束一个方法
热门推荐
superjunjin的专栏
06-24 1万+
在java中，可以使用return语句直接结束一个方法的执行。 使用return结束方法示例 public class Method{        public static void main(String[] args){               System.out.println("1,调用fun()方法之前。");               fun(10);
Android中onTouchEvent的返回return super.onTouchEvent(ev);数组越界问题解决方法.。。
zhangjunjie1111的博客
11-05 1478
今天写自定义上下拉刷新加载ListView的时候遇到了个问题....有时候 如果上下拉的时候会出java.lang.IndexOutOfBoundsException: Invalid index 2, size is 1 这个异常 ...然后就机制的加了个 try { return super.onTouchEvent(ev); }catch (Exception e){ ret
super關鍵字
weixin_30907523的博客
01-01 123
super 关键字 我们知道，this关键字总是指向函数所在的当前对象，ES6 又新增了另一个类似的关键字super，指向当前对象的原型对象。 const proto = { foo: 'hello' }; const obj = { find() { return super.foo; } }; Object.setPrototypeOf(obj,...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值