面向对象-抽象类

STM32H723串口接收全为0 & CAN错误中断问题 STM32H723串口接收全为0 和 叠加的导致CAN错误问题 阅读详情

抽象类的特点:


/*
	抽象类的概述:
		动物不应该定义为具体的东西,而且动物中的吃,睡等也不应该是具体的。
		我们把一个不是具体的功能称为抽象的功能,而一个类中如果有抽象的功能,该类必须是抽象类。
		
	抽象类的特点:
		A:抽象类和抽象方法必须用abstract关键字修饰
		B:抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类
		C:抽象类不能实例化
			因为它不是具体的。
			抽象类有构造方法,但是不能实例化?构造方法的作用是什么呢?
			用于子类访问父类数据的初始化
		D:抽象的子类
			a:如果不想重写抽象方法,该子类是一个抽象类。
			b:重写所有的抽象方法,这个时候子类是一个具体的类。
			
		抽象类的实例化其实是靠具体的子类实现的。是多态的方式。
			Animal a = new Cat();
*/

//abstract class Animal //抽象类的声明格式
abstract class Animal {
	//抽象方法
	//public abstract void eat(){} //空方法体,这个会报错。抽象方法不能有主体
	public abstract void eat();
	
	//抽象类有构造方法,但是不能实例化
	public Animal(){}
}

//要么子类是抽象类
abstract class Dog extends Animal {}

//要么子类是具体类,重写抽象方法
class Cat extends Animal {
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

class AbstractDemo {
	public static void main(String[] args) {
		//创建对象
		//Animal a = new Animal();//Animal是抽象的; 无法实例化,可以通过子类实例化
		
		//通过多态的方式,多态主要不是在具体类之间使用,而是在抽象类之间使用
		Animal a = new Cat();
		a.eat();
	}
}

抽象类的成员特点:


/*
	抽象类的成员特点:
		成员变量:既可以是变量,也可以是常量。
		构造方法:有。
					用于子类访问父类数据的初始化。
		成员方法:既可以是抽象的,也可以是非抽象的。
		
	抽象类的成员方法特性:
		A:抽象方法   强制要求子类做的事情。
		B:非抽象方法 子类继承的事情,提高代码复用性。
*/
abstract class Animal {
	public int num = 10;
	public final int num2 = 20;

	public Animal() {}
	
	public Animal(String name,int age){}
	
	public abstract void show();
	
	public void method() {
		System.out.println("method");
	}
}

class Dog extends Animal {
	public void show() {
		System.out.println("show Dog");
	}
}

class AbstractDemo2 {
	
	public static void main(String[] args) {
		//创建对象
		Animal a = new Dog();
		a.num = 100;
		System.out.println(a.num);//100
		
		a.num2 = 200;
		System.out.println(a.num2);//报错,public final int num2 = 20;是常量
		System.out.println("--------------");
		
		a.show();  //show Dog
		a.method();//method
	}
	
}

抽象类练习猫狗案例:


/*
	猫狗案例
		具体事物:猫,狗
		共性:姓名,年龄,吃饭

	分析:从具体到抽象
		猫:
			成员变量:姓名,年龄
			构造方法:无参,带参
			成员方法:吃饭(猫吃鱼)
			
		狗:
			成员变量:姓名,年龄
			构造方法:无参,带参
			成员方法:吃饭(狗吃肉)
			
		因为有共性的内容,所以就提取了一个父类。动物。
		但是又由于吃饭的内容不一样,所以吃饭的方法是抽象的,
		而方法是抽象的类,类就必须定义为抽象类。
		
		抽象动物类:
			成员变量:姓名,年龄
			构造方法:无参,带参
			成员方法:吃饭();
	
	实现:从抽象到具体
		动物类:
			成员变量:姓名,年龄
			构造方法:无参,带参
			成员方法:吃饭();
			
		狗类:
			继承自动物类
			重写吃饭();
			
		猫类:
			继承自动物类
			重写吃饭();
*/
//定义抽象的动物类
abstract class Animal {
	//姓名
	private String name;
	//年龄
	private int age;
	
	public Animal() {}
	
	public Animal(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 abstract void eat();
}

//定义具体的狗类
class Dog extends Animal {
	public Dog() {}
	
	public Dog(String name,int age) {
		super(name,age);
	}
	
	public void eat() {
		System.out.println("狗吃肉");
	}
}

//定义具体的猫类
class Cat extends Animal {
	public Cat() {}
	
	public Cat(String name,int age) {
		super(name,age);
	}
	
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

//测试类
class AbstractTest {
	public static void main(String[] args) {
		//测试狗类
		//具体类用法
		//方式1:
		Dog d = new Dog();
		d.setName("旺财");
		d.setAge(3);
		System.out.println(d.getName()+"---"+d.getAge());
		d.eat();
		
		//方式2:
		Dog d2 = new Dog("旺财",3);
		System.out.println(d2.getName()+"---"+d2.getAge());
		d2.eat();
		System.out.println("---------------------------");
		
		Animal a = new Dog();
		a.setName("旺财");
		a.setAge(3);
		System.out.println(a.getName()+"---"+a.getAge());
		a.eat();
		
		Animal a2 = new Dog("旺财",3);
		System.out.println(a2.getName()+"---"+a2.getAge());
		a2.eat();
		
		//练习:测试猫类
	}
	
}

抽象类练习老师案例:


/*
	老师案例
		具体事物:基础班老师,就业班老师
		共性:姓名,年龄,讲课。

	分析:	
		基础班老师
			姓名,年龄
			讲课。
		就业班老师
			姓名,年龄
			讲课。
	实现:
		老师类
			基础班老师
			就业班老师
*/
//定义抽象的老师类
abstract class Teacher {
	//姓名
	private String name;
	//年龄
	private int age;
	
	public Teacher() {}
	
	public Teacher(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 abstract void teach();
}

//基础班老师类
class BasicTeacher extends Teacher {
	public BasicTeacher(){}
	
	public BasicTeacher(String name,int age) {
		super(name,age);
	}
	
	public void teach() {
		System.out.println("基础班老师讲解JavaSE");
	}
}

//就业班老师类
class WorkTeacher extends Teacher {
	public WorkTeacher(){}
	
	public WorkTeacher(String name,int age) {
		super(name,age);
	}
	
	public void teach() {
		System.out.println("就业班老师讲解JavaEE");
	}
}

class AbstractTest2 {
	public static void main(String[] args) {
		//具体的类测试,自己玩
		
		//测试(多态)
		//基础班老师
		Teacher t = new BasicTeacher();
		t.setName("刘意");
		t.setAge(30);
		System.out.println(t.getName()+"---"+t.getAge());
		t.teach();
		System.out.println("--------------");
		
		t = new BasicTeacher("刘意",30);
		System.out.println(t.getName()+"---"+t.getAge());
		t.teach();
		System.out.println("--------------");
		
		//就业班老师
		t = new WorkTeacher();
		t.setName("林青霞");
		t.setAge(27);
		System.out.println(t.getName()+"---"+t.getAge());
		t.teach();
		System.out.println("--------------");
		
		t = new WorkTeacher("林青霞",27);
		System.out.println(t.getName()+"---"+t.getAge());
		t.teach();
	}
}

抽象类练习学员案例:


/*
	学生案例
		具体事务:基础班学员,就业班学员
		共性:姓名,年龄,班级,学习,吃饭

	分析:
		基础班学员
			成员变量:姓名,年龄,班级
			成员方法:学习,吃饭
		就业班学员
			成员变量:姓名,年龄,班级
			成员方法:学习,吃饭
			
		得到一个学员类。
			成员变量:姓名,年龄,班级
			成员方法:学习,吃饭
			
	实现:
		学员类
		基础班学员
		就业班学员
*/
//定义抽象学员类
abstract class Student {
	//姓名
	private String name;
	//年龄
	private int age;
	//班级
	private String grand;
	
	public Student() {}
	
	public Student(String name,int age,String grand) {
		this.name = name;
		this.age = age;
		this.grand = grand;
	}
	
	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 String getGrand() {
		return grand;
	}
	
	public void setGrand(String grand) {
		this.grand = grand;
	}
	
	//学习
	public abstract void study();
	
	//吃饭
	public void eat() {
		System.out.println("学习累了,就该吃饭");
	}
}

//具体基础班学员类
class BasicStudent extends Student {
	public BasicStudent() {}
	
	public BasicStudent(String name,int age,String grand) {
		super(name,age,grand);
	}
	
	public void study() {
		System.out.println("基础班学员学习的是JavaSE");
	}
}

//具体就业班学员类
class WorkStudent extends Student {
	public WorkStudent() {}
	
	public WorkStudent(String name,int age,String grand) {
		super(name,age,grand);
	}
	
	public void study() {
		System.out.println("就业班学员学习的是JavaEE");
	}
}

class AbstractTest3 {
	public static void main(String[] args) {
		//我仅仅测试基础班学员
		//按照多态的方式测试
		Student s = new BasicStudent();
		s.setName("林青霞");
		s.setAge(27);
		s.setGrand("1111");
		System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand());
		s.study();
		s.eat();
		System.out.println("--------------");
		
		s = new BasicStudent("武鑫",48,"1111");
		System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand());
		s.study();
		s.eat();
		
		//就业班测试留给自己玩
	}
}

抽象类练习员工案例:


/*
	假如我们在开发一个系统时需要对员工类进行设计,员工包含3个属性:姓名、工号以及工资。
	经理也是员工,除了含有员工的属性外,另为还有一个奖金属性。
	请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。
	
	分析:
		普通员工类
			成员变量:姓名、工号以及工资。
			成员方法:工作
		经理类:
			成员变量:姓名、工号以及工资,奖金属性
			成员方法:工作
			
	实现:
		员工类:
		普通员工类:
		经理类:
*/
//定义员工类
abstract class Employee {
	//姓名、工号以及工资
	private String name;
	private String id;
	private int salary;
	
	public Employee() {}
	
	public Employee(String name,String id,int salary) {
		this.name = name;
		this.id = id;
		this.salary = salary;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public String getId() {
		return id;
	}
	
	public void setId(String id) {
		this.id = id;
	}
	
	public int getSalary() {
		return salary;
	}
	
	public void setSalary(int salary) {
		this.salary = salary;
	}
	
	//工作
	public abstract void work();
}

//普通员工类
class Programmer extends Employee {
	public Programmer(){}
	
	public Programmer(String name,String id,int salary) {
		super(name,id,salary);
	}
	
	public void work() {
		System.out.println("按照需求写代码");
	}
}

//经理类
class Manager extends Employee {
	//奖金
	private int money; //bonus 奖金

	public Manager(){}
	
	public Manager(String name,String id,int salary,int money) {
		super(name,id,salary);
		this.money = money;
	}
	
	public void work() {
		System.out.println("跟客户谈需求");
	}
	
	public int getMoney() {
		return money;
	}
	
	public void setMoney(int money) {
		this.money = money;
	}
}

class AbstractTest4 {
	public static void main(String[] args) {
		//测试普通员工
		Employee emp = new Programmer();
		emp.setName("林青霞");
		emp.setId("czbk001");
		emp.setSalary(18000);
		System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
		emp.work();
		System.out.println("-------------");
		emp = new Programmer("林青霞","czbk001",18000);
		System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
		emp.work();
		System.out.println("-------------");
		

		//由于子类有特有的内容,所以我们用子类来测试
		Manager m = new Manager();
		m.setName("刘意");
		m.setId("czbk002");
		m.setSalary(8000);
		m.setMoney(2000);
		System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
		m.work();
		System.out.println("-------------");
		
		//通过构造方法赋值
		m = new Manager("刘意","czbk002",8000,2000);
		System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
		m.work();
	}
}

抽象类中的小问题:


/*
一个类如果没有抽象方法,可不可以定义为抽象类?如果可以,有什么意义?
	可以。
	意义:不让创建对象。你要访问它,只能通过它的子类。

abstract不能和哪些关键字共存?
	private	冲突
	final	冲突	
	static	无意义
*/
abstract class Fu {
	//public abstract void show();为了让子类重写的
	
	//private abstract void show();//报错:非法的修饰符组合: abstract和private,私有不能被继承,子类也就不能重写了,
	                               //而抽象类中的抽象方法是要求子类重写的
	
	//报错:非法的修饰符组合
	//final abstract void show();	
	
	//报错:非法的修饰符组合,访问一个没有方法体的方法没有意义
	static abstract void show();
	
	public static void method() {
		System.out.println("method");
	}
}

class Zi extends Fu {
	public void show() {}
}

class AbstractDemo3 {
	public static void main(String[] args) {
		Fu.method();
	}
}


RT-DETR改进目录一览 | 涉及卷积层、轻量化、注意力、损失函数、Backbone、SPPF、Neck、检测头等全方位改进 1️⃣本专栏已更新260多种不同的改进方法,所使用并改进的每一个模块均包含详细的模块分析、原理讲解、个人总结、多种改进方式以及完整的修改流程,所有改进100%可直接运行。2️⃣所有改进点均为近三年顶会,顶刊提出的先进算法,将其融入到中,紧跟学术热点,适应不同的任务场景。3️⃣团队内发表数篇SCI论文,熟悉完整的发表流程,订阅专栏即可进群享受模型训练、模型改进、论文写作、投稿选刊,从入门到论文的各种答疑内容。4️⃣专栏内容会持续更新,最近更新时间:2024-12-4。项目介绍在大家购买专栏后,加入学习 阅读详情

相关推荐

从SAS接口到InfiniBand:一张图看懂数据中心硬件‘黑话’(SFF-8643/8644、QSFP112、NDR/HDR/EDR)

本文深入解析数据中心硬件术语,从SAS接口标准(SFF-8643/8644)到速率标识(NDR/HDR/EDR),帮助工程师快速理解关键性能指标。特别对比了PCIe卡规格(HHHL/FHHL)和光模块选择(QSFP112/OSFP),并探讨InfiniBand在高性能网络中的优势,为硬件选型提供实用指南。

weixin_32103009的博客 434

java抽象类的特点

一、特点: 1、方法只有声明,没有实现时,该方法就是抽象方法,需要被abstract修饰。 2、抽象类不可以被实例化。因为用抽象方法无意义。 3、抽象类必须由其子类覆盖了所有的抽象方法,该子类才可以被实例化,否则这个子类还是抽象类。 4,抽象类中的抽象方法 : 强制要求子类做的事 抽象类中非的抽象方法 : 子类继承的事情,提高代码的复用性 二、细节: 1、抽象类中有构造函数,用于给子类初始化。 2...

weixin_43455473的博客 2414

校招总结—FPGA从入门到放弃

校招总结—FPGA从入门到放弃 感谢咸鱼FPGA的授权转发,原文地址为https://www.cnblogs.com/xianyufpga/ 其实 offer 早就定下来了,最近忙着入党考试,现在才腾出时间来写个总结。我校招开始于 7 月底,算是比较晚了,后面加了各大校招交流群,发现很多同学都是过完年后就开始打磨项目、复习基础、寻找实习。对比之下我这准备确实仓促,不过结果还算满意。 ...

qq_31515205的博客 8607

抽象类的特点

1.抽象类中不一定有抽象方法,但是有抽象方法的类必须为抽象类 2.抽象类不能实例化 3.抽象类由具体的子类进行实例化 4.子类必须对父类(抽象类)中的所有抽象方法进行重写 5.在抽象类中可以定义非抽象方法 6.子类如果不重写抽象类中的抽象方法,则该类还是抽象类 7.抽象类中可以有构造方法,用于子类访问父类是的数据初始化 注意: 1.在方法上加上abstract 进行修饰,则该方法是为抽象方法(如果该类中存在一个抽象方法,则该类必须是抽象类) 2.在一个抽象类中可以存在多个抽象方..

m0_61664184的博客 2224

Feko仿真GPS微带天线学习笔记

为了优化方便,使参数变量化,所以定义几个变量在CADFEKO左侧浏览器中如图所示定义变量,如下表贴片的尺寸切角尺寸feed =-6.4馈电点距坐标原点的距离sub_w=45基板的宽度sub_d=45基板的长度sub_h=5基板的高度epsR=5.6介电常数损耗角正切。

qq_36521926的博客 3992

【WRF模拟】保存wrf输出文件到指定目录+仅输出指定空间域/变量文件

修改wrf命令以更改指定输出文件目录等

WW、forever的博客 546

3.抽象类:什么是抽象类???抽象类的特点有哪些???

跟汤老师学Java笔记:抽象类 完成:第一遍 1.什么是抽象类? 被abstract修饰的类,称为抽象类 定义方式: public abstract class 类名{ } 抽象类不能被实例化,即不能使用new创建一个对象,只能被继承 被abstract修饰的方法,称为抽象方法 定义方式: public abstract 返回值类型 方法名(); 抽象方法只有声明,没有具体实现,即没有方法体,以分号结尾 2. 抽象类的特点有哪些? 抽象类可以防止父类被实例化: 抽象类不能被实例化,即不能使用new创建一个对

ADbyCool的博客 1万+

YOLOv12优化:原创自研 | 带有注意力机制的隐藏状态混合器的状态空间(HSM-SSD),实现暴力涨点 | CVPR2025 EfficientViM

可以将 带有注意力机制的隐藏状态混合器的状态空间(HSM-SSD)中的注意力机制换成专栏其他注意力机制 ,那么你就能实现独一无二的原创。

①答疑群聊服务;②YOLO大模型知识问答系统;③计算机视觉论文生成智能体; 667

抽象类的特征

2. 抽象类不一定需要包含抽象方法,也就是说,Abstract类中不一定需要Abstract方法。7. 如果一个类继承了 抽象类, 则它必须实现抽象类的所有抽象方法,除非他自己也声明为abstract抽象类。5. 抽象类可以有任意成员, 抽象类的本质还是类,比如,非抽象方法,构造器, 静态属性等等。3. 一旦包含了abstract方法,则该类必须是abstract抽象类。4. abstract只能修饰类和方法,不能修饰属性和其他的。6. 抽象类不能有主体,如下是错误代码块。1. 抽象类不能被实例化。

m0_53753920的博客 688

【camera-radar】基于ROS的多传感器融合感知系统实现(雷达+相机)(2)

实现功能:代码下载地址:下载地址 1)基于深度学习的目标检测;2)基于雷达的距离估计和预测;3)多传感器感知结果融合模块。 相机感知模块解析 4. Run nodes: python3 fusion_node/main.py python3 gps_node/main.py python3 radar_node/main.py python3 2d_detection_node/main.py #(additional instructions in 2d_detection_node/README.m

踟蹰横渡口,彳亍上滩舟。 9952

借助Gemini 3 Pro高效解决课题申报中的五大核心痛点,亲测有效经验分享

之前给大家分享过关于AI辅助课题申报的相关的内容,涵盖了申报书部分撰写技巧,但没针对性拆解各位同仁在实际申报时遇到的卡壳的地方。比如选题范围拿捏不准,定的太大,根本没法落地完成;定的太小,研究价值则体现不了;写综述时,容易单纯罗列文献,缺乏批判性视角,没办法自然融入自己的判断,找不到研究缺口;研究方法部分,可能担心方法设计不够严谨,别人难以复现.....针对这些申报中的高频痛点,接下来七哥会从五个核心要点出发,借助Gemini 3 Pro高效解决这些痛点。

智能AI让学术科研更容易 703

Java面向对象那些事之抽象类、接口

本文主要介绍Java面向对象的两个重要内容——抽象类和接口,感兴趣或者正在学抽象类和接口的小伙伴们进来看看吧,绝不会让你失望!

weixin_45676761的博客 723

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

【Java】面向对象.抽象类

java.面向对象.抽象类 抽象类: 1.abstract:抽象的 2.只有当子类中重写父类中所有的抽象方法时,才能实现实例化。否则子类还是一个抽象类。 3.抽象方法只声明不实现,不能用static修饰, 子类无法继承private方法,所以父类中含有private的方法不能被重写。 同理,含有final的方法或类,不能被重写或继承 注意: 1.抽象类不能被实例化 2.虽然抽象类没有办法实例化,但.........

懂得一千零一种,赋予你失败的方法! 489

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

面向对象、接口/抽象类

面向对象 主要内容 对象和类 重写/重载 继承 多态 封装 接口/抽象类 学习目标 理解类与对象概念 理解对象销毁机制 理解重写与重载的区别 理解面向对象程序设计基本原则 掌握面向对象三大特性 理解接口和抽象类的区别 一、对象 1.1 对象与类 ”万物皆可对象。“ 对象:对象是类的一个实例,具有自己的状态与行为。 类:类是一个模板,是对对象的行为与状态的一种抽象描述。 例如: 动物是一个类,而狗则是类的一个对象。 它的状态有:名字、品种、颜色,行为有:叫、摇尾巴和跑… 在软件开发中,状态

Stay Hungry, Stay Foolish! 931

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

Java面向对象探秘:抽象类与接口

本文介绍了Java面向对象编程中的抽象类和接口两大核心概念。抽象类作为"蓝图"或"模版"定义了共同特征和行为但不提供全部实现,通过继承和子类实现具体功能;接口则完全定义方法规范,要求实现类必须完成所有方法。两者都支持多态性,但存在显著差异:抽象类可以有构造方法和具体方法,而接口只能定义方法规范;类只能单继承抽象类,但可以实现多个接口。文章通过生动的商业比喻和代码示例,帮助读者理解这两个看似"抽象"却颇具实用价值的概念,为Java面向对象编程打下坚实

码力斜杠哥 633

JAVA面向对象——多态、抽象类练习

JAVA面向对象——多态、抽象类练习 题目:豆豆家养了两只家禽Poultry:一只鸡Chicken和一只鸭Duck。请再写一个类Master,有一个方cry(); 分析: (1)写一个抽象类Poultry,他里面有属性name,sex,他里面有回来方法back() (2)写一个类Chicken,继承抽象类Poultry (3)写一个类Duck,继承抽象类Poultry (4)再写一个类Master,里面有一个方法cry(),传一个字符串参数进去,如果传入是是小花,就返回小鸡,如果传的是小林,就返回鸭子 (5

weixin_44193063的博客 942

JavaSE面向对象之抽象类08

JavaSE面向对象之抽象类08 第二章 抽象类 2.1 概述 由来 父类中的方法,被它的子类们重写,子类各自的实现都不尽相同。那么父类的方法声明和方法主体,只有声明还有 意义,而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定,包含抽象方法 的类就是抽象类。 定义 抽象方法 : 没有方法体的方法。 抽象类:包含抽象方法的类。 2.2 abstract使用格式 抽象方法 使用 abstract 关键字修...

helloworld工程师的博客 289

面向对象的抽象类,以及面向对象的特征多态

抽象类是一种特殊的方法,他只进行声明,不能实现。所以也就无法创建对象。抽象方法用abstra关键字进行修饰。(注意,抽象方法的类必须用abstract进行修饰类,而抽象类不一定会有抽象法)

2301_76460223的博客 151

面向对象的抽象类

6.抽象类不能被实例化,虽然抽象类中可以有不抽象的方法,但仍然不能实例化,原因在于,一旦抽象类中有抽象方法时,则就不能实例化了,前后会矛盾的,故抽象类不能被实例化。5.既然子类能够实现抽象父类的方法,那么父类的抽象方法的访问修饰符必然是public,否则不能实现。在这两部分传递参数的接口,传统编程就是具体的内部类型或者结构什么的。是指面向过程编程,分为具体功能实现的函数,和调用这些函数的主程序。3.一个类中有抽象的方法,则该类一定是抽象类,反过来不一定。1.抽象的背景是因为定义一些方法时,代码不确定。...

tck66的博客 761

java面向对象 抽象类

1.当编写一个类时,我们往往会为该类定义一些方法,这些方法是用来描述该类的功能具体实现方式, 那么这些方法都有具体的方法体。 但是有的时候,某个父类只是知道子类应该包含怎么样的方法,但是无法准确知道子类如何实现这 些方法。比如一个图形类应该有一个求周长的方法,但是不同的图形求周长的算法不一样。那该怎么办 呢? 分析事物时,发现了共性内容,就出现向上抽取。会有这样一种特殊情况,就是方法功能声明...

风雨过后的博客 265

Java面向对象-抽象类

Java抽象类的概念 java面向对象具有封装,继承,抽象,多态这四种特征,其中抽象特征也是java面向对象重要的特征之一!在面向对象的概念中,所有的对象都是通过类来描绘的,但不是所有的类都是用来描绘对象的,比如抽象类,抽象类没有包含足够的信息描绘对象时是无法描绘一个具体的对象的,抽象类跟继承中的所谓的父类类似!不同的是抽象类不能实例化调用!只能被继承时才能被使用,抽象类好比如一个父类模板,设计者...

weixin_44564151的博客 276

Java面向对象-继承与抽象类

面向对象-继承与抽象类* 继承的概述 继承:多个类的有共同的成员变量和方法,抽取到另外一个类中(父类),在让多个类去继承这个父类,我们的多个类就可以获取父类中的成员了 extends package con_01; public class ExtendsDemo{ } class Game{ String name; double version;//版本号n String agent...

weixin_44681767的博客 234

面向对象设计 接口 抽象类

接口和抽象类是Java面向对象设计的两个基础机制。 接口:接口是对行为的抽象,它是抽象方法的集合,利用接口可以达到API定义和实现分离的目的。接口不能实例化,不能包含任何非常量成员,任何field(字段/成员变量)都是隐含着public static final的意义;同时没有非静态方法实现,要么是抽象方法,要么是静态方法【均无实际代码块{..}】。Java类使用implements来实现接口。 ——在java8以后,接口中可以添加使用default 修饰的方法(可以...

qq_56754651的博客 400

【JAVA面向对象之抽象类】

目录Java 抽象类抽象类抽象方法抽象类与子类 Java 抽象类 在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。 抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法和构造方法的访问方式和普通类一样。 由于抽象类不能实例化对象,所以抽象类必须被继承,才能被使用。也是因为这个原因,通常在设计阶段决定要不要设计抽象类。 父类包含了子类集合的常见的方法,但是由于

Rita_zf的博客 243

JAVA面向对象抽象类

一、抽象类 1、面向对象的核心–面向抽象编程; 抽象类:包含了抽象方法的 类 就是抽象类; 抽象方法:方法中不包含函数体的方法,称为抽象方法;抽象方法必须在子类中给出具体实现,但抽象类本身不能创建对象。 例:public abstract class ChouXiang{ //抽象类 类中间接或者直接 包含抽象方法 就是抽象类 public abstract voi

programmer_dog的博客 249

Java学习——面向对象之抽象类与接口

Java学习——面向对象之抽象类与接口 1.抽象类 抽象类的概述:在Java中,一个方法如果没有方法体,即没有具体的实现,则称该方法为抽象方法。如果一个类中存在抽象方法,那么这个类就是抽象类。 抽象类的特点: 1.抽象类和抽象方法必须用abstract关键字修饰 2.抽象类不一定有抽象方法,有抽象方法的类一定是抽象类 /* 抽象类 */ public abstract class Tes...

qq_43411550的博客 224
上一篇: 面向对象-static关键字
下一篇: 面向对象-接口
ZHOU_VIP
博客等级 码龄11年 1万+粉丝 1779原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

ZHOU_VIP

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

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

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

打赏作者

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

抵扣说明:

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

余额充值