java学习笔记day09 final、多态、抽象类、接口

最新推荐文章于 2024-08-15 14:47:41 发布
最新推荐文章于 2024-08-15 14:47:41 发布
阅读量187 收藏 1
点赞数
文章标签： java javase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51724235/article/details/111924613
版权
这篇博客详细介绍了Java中的final关键字，多态的概念、好处、弊端及转型，抽象类的特性与应用场景，以及接口的要点和区别。内容包括多态的内存图解、抽象类案例分析以及接口的案例研究。
摘要由CSDN通过智能技术生成

java学习笔记day09

思维导图

final 、 多态 、 抽象类 、 接口 （都很重要）

一、final

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

二、多态

在这里插入图片描述

多态中的成员访问特点⭐ 【P237】

在这里插入图片描述

多态的好处 【P239]

在这里插入图片描述

多态的弊端

在这里插入图片描述

向上转型、向下转型 ⭐【P241】

在这里插入图片描述
形象案例：孔子装爹

多态的问题理解：
	class 孔子爹 {
		public int age = 40;
		
		public void teach() {
			System.out.println("讲解JavaSE");
		}
	}
	
	class 孔子 extends 孔子爹 {
		public int age = 20;
		
		public void teach() {
			System.out.println("讲解论语");
		}
		
		public void playGame() {
			System.out.println("英雄联盟");
		}
	}
	
	//Java培训特别火,很多人来请孔子爹去讲课，这一天孔子爹被请走了
	//但是还有人来请，就剩孔子在家，价格还挺高。孔子一想，我是不是可以考虑去呢?
	//然后就穿上爹的衣服，带上爹的眼睛，粘上爹的胡子。就开始装爹
	//向上转型
	孔子爹 k爹 = new 孔子();
	//到人家那里去了
	System.out.println(k爹.age); //40
	k爹.teach(); //讲解论语
	//k爹.playGame(); //这是儿子才能做的
	
	
	//讲完了，下班回家了
	//脱下爹的装备，换上自己的装备
	//向下转型
	孔子 k = (孔子) k爹; 
	System.out.println(k.age); //20
	k.teach(); //讲解论语
	k.playGame(); //英雄联盟

多态继承中的内存图解⭐⭐【P242】

在这里插入图片描述

多态中对象变化的内存图解 【P243】

在这里插入图片描述
在这里插入图片描述

多态的3道练习题【P245~P246】⭐

1.猫与狗

/*
	多态练习：猫狗案例
*/
class Animal {
	public void eat(){
		System.out.println("吃饭");
	}
}

class Dog extends Animal {
	public void eat() {
		System.out.println("狗吃肉");
	}
	
	public void lookDoor() {
		System.out.println("狗看门");
	}
}

class Cat extends Animal {
	public void eat() {
		System.out.println("猫吃鱼");
	}
	
	public void playGame() {
		System.out.println("猫捉迷藏");
	}
}

class DuoTaiTest {
	public static void main(String[] args) {
		//定义为狗
		Animal a = new Dog();
		a.eat();
		System.out.println("--------------");
		//还原成狗
		Dog d = (Dog)a;
		d.eat();
		d.lookDoor();
		System.out.println("--------------");
		//变成猫
		a = new Cat();
		a.eat();
		System.out.println("--------------");
		//还原成猫
		Cat c = (Cat)a;
		c.eat();
		c.playGame();
		System.out.println("--------------");
		
		//演示错误的内容
		//Dog dd = new Animal();
		//Dog ddd = new Cat();
		//ClassCastException
		//Dog dd = (Dog)a;
	}
}

2.南方人与北方人

/*
	不同地方饮食文化不同的案例
*/
class Person {
	public void eat() {
		System.out.println("吃饭");
	}
}

class SouthPerson extends Person {
	public void eat() {
		System.out.println("炒菜,吃米饭");
	}
	
	public void jingShang() {
		System.out.println("经商");
	}
}

class NorthPerson extends Person {
	public void eat() {
		System.out.println("炖菜,吃馒头");
	}
	
	public void yanJiu() {
		System.out.println("研究");
	}
}

class DuoTaiTest2 {
	public static void main(String[] args) {
		//测试
		//南方人
		Person p = new SouthPerson();
		p.eat();
		System.out.println("-------------");
		SouthPerson sp = (SouthPerson)p;
		sp.eat();
		sp.jingShang();
		System.out.println("-------------");
		
		//北方人
		p = new NorthPerson();
		p.eat();
		System.out.println("-------------");
		NorthPerson np = (NorthPerson)p;
		np.eat();
		np.yanJiu();
	}
}

3.我爱你（多层继承练习） ⭐

/*
	看程序写结果:先判断有没有问题，如果没有，写出结果
	
	多态的成员访问特点：
		方法：编译看左边，运行看右边。
		
	继承的时候：
		子类中有和父类中一样的方法，叫重写。
		子类中没有父亲中出现过的方法，方法就被继承过来了。
*/
class A {
	public void show() {
		show2();
	}
	public void show2() {
		System.out.println("我");
	}
}
class B extends A {
	/*
	public void show() {
		show2();
	}
	*/

	public void show2() {
		System.out.println("爱");
	}
}
class C extends B {
	public void show() {
		super.show();
	}
	public void show2() {
		System.out.println("你");
	}
}
public class DuoTaiTest4 {
	public static void main(String[] args) {
		A a = new B();
		a.show();
		
		B b = new C();
		b.show();
	}
}

三、抽象类

在这里插入图片描述

抽象类的成员特点

在这里插入图片描述

抽象类的案例

1.猫狗案例
在这里插入图片描述
在这里插入图片描述

//定义抽象的动物类
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();
		
		//练习：测试猫类
	}
}

2.老师案例

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

	分析：	
		基础班老师
			姓名，年龄
			讲课。
		就业班老师
			姓名，年龄
			讲课。
	实现：
		老师类
			基础班老师
			就业班老师
*/
//定义抽象的老师类
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();
	}
}

3.学员案例

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

	分析：
		基础班学员
			成员变量：姓名，年龄，班级
			成员方法：学习，吃饭
		就业班学员
			成员变量：姓名，年龄，班级
			成员方法：学习，吃饭
			
		得到一个学员类。
			成员变量：姓名，年龄，班级
			成员方法：学习，吃饭
			
	实现：
		学员类
		基础班学员
		就业班学员
*/
//定义抽象学员类
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();
		
		//就业班测试留给自己玩
	}
}

4.员工案例

/*
	假如我们在开发一个系统时需要对员工类进行设计，员工包含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("-------------");
		
		/*
		emp = new Manager();
		emp.setName("刘意");
		emp.setId("czbk002");
		emp.setSalary(8000);
		emp.setMoney(2000);
		*/
		//由于子类有特有的内容，所以我们用子类来测试
		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();
	}
}

抽象类的几个小问题

在这里插入图片描述

四、接口

接口特点

在这里插入图片描述

接口成员特点⭐【P257】

在这里插入图片描述

类与类、类与接口、接口与接口的关系【P258】

在这里插入图片描述

抽象类与接口的区别⭐

在这里插入图片描述

接口的两个案例⭐⭐⭐

1.猫狗跳高案例

/*
	猫狗案例,加入跳高的额外功能
	
	分析：从具体到抽象
		猫：
			姓名,年龄
			吃饭，睡觉
		狗：
			姓名,年龄
			吃饭，睡觉
			
		由于有共性功能，所以，我们抽取出一个父类：
		动物：
			姓名,年龄
			吃饭();
			睡觉(){}
			
		猫：继承自动物
		狗：继承自动物
		
		跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口
		接口：
			跳高
			
		部分猫：实现跳高
		部分狗：实现跳高
	实现；
		从抽象到具体
		
	使用：
		使用具体类
*/
//定义跳高接口
interface Jumpping {
	//跳高功能
	public abstract void jump();
}

//定义抽象类
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();
	
	//睡觉(){}
	public void sleep() {
		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 Dog extends Animal {
	public Dog(){}
	
	public Dog(String name,int age) {
		super(name,age);
	}
	
	public void eat() {
		System.out.println("狗吃肉");
	}
}

//有跳高功能的猫
class JumpCat extends Cat implements Jumpping {
	public JumpCat() {}
	
	public JumpCat(String name,int age) {
		super(name,age);
	}

	public void jump() {
		System.out.println("跳高猫");
	}
}

//有跳高功能的狗
class JumpDog extends Dog implements Jumpping {
	public JumpDog() {}
	
	public JumpDog(String name,int age) {
		super(name,age);
	}

	public void jump() {
		System.out.println("跳高狗");
	}
}

class InterfaceTest {
	public static void main(String[] args) {
		//定义跳高猫并测试
		JumpCat jc = new JumpCat();
		jc.setName("哆啦A梦");
		jc.setAge(3);
		System.out.println(jc.getName()+"---"+jc.getAge());
		jc.eat();
		jc.sleep();
		jc.jump();
		System.out.println("-----------------");
		
		JumpCat jc2 = new JumpCat("加菲猫",2);
		System.out.println(jc2.getName()+"---"+jc2.getAge());
		jc2.eat();
		jc2.sleep();
		jc2.jump();
		
		//定义跳高狗并进行测试的事情自己完成。
	}
}

2.老师学生抽烟案例

/*
	老师和学生案例,加入抽烟的额外功能
	
	分析：从具体到抽象
		老师：姓名，年龄，吃饭，睡觉
		学生：姓名，年龄，吃饭，睡觉
		
		由于有共性功能，我们提取出一个父类，人类。
		
		人类：
			姓名，年龄
			吃饭();
			睡觉(){}
			
		抽烟的额外功能不是人或者老师，或者学生一开始就应该具备的，所以，我们把它定义为接口
		
		抽烟接口。

		部分老师抽烟：实现抽烟接口
		部分学生抽烟：实现抽烟接口
		
	实现：从抽象到具体
		
	使用：具体
*/
//定义抽烟接口
interface Smoking {
	//抽烟的抽象方法
	public abstract void smoke();
}

//定义抽象人类
abstract 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 abstract void eat();
	
	//睡觉(){}
	public void sleep() {
		System.out.println("睡觉觉了");
	}
}

//具体老师类
class Teacher extends Person {
	public Teacher() {}
	
	public Teacher(String name,int age) {
		super(name,age);
	}
	
	public void eat() {
		System.out.println("吃大白菜");
	}
}

//具体学生类
class Student extends Person {
	public Student() {}
	
	public Student(String name,int age) {
		super(name,age);
	}
	
	public void eat() {
		System.out.println("吃红烧肉");
	}
}

//抽烟的老师
class SmokingTeacher extends Teacher implements Smoking {
	public SmokingTeacher() {}
	
	public SmokingTeacher(String name,int age) {
		super(name,age);
	}

	public void smoke() {
		System.out.println("抽烟的老师");
	}
}

//抽烟的学生
class SmokingStudent extends Student implements Smoking {
	public SmokingStudent() {}
	
	public SmokingStudent(String name,int age) {
		super(name,age);
	}

	public void smoke() {
		System.out.println("抽烟的学生");
	}
}

class InterfaceTest2 {
	public static void main(String[] args) {
		//测试学生
		SmokingStudent ss = new SmokingStudent();
		ss.setName("林青霞");
		ss.setAge(27);
		System.out.println(ss.getName()+"---"+ss.getAge());
		ss.eat();
		ss.sleep();
		ss.smoke();
		System.out.println("-------------------");
		
		SmokingStudent ss2 = new SmokingStudent("刘意",30);
		System.out.println(ss2.getName()+"---"+ss2.getAge());
		ss2.eat();
		ss2.sleep();
		ss2.smoke();
		
		//测试老师留给自己练习
	}
}
「已注销」
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JAVASE进阶day02（多态，抽象类，接口）
qq_65095414的博客
07-01 535
day02
Java复习之路-day09-面向对象（多态、抽象类、接口）
qq_26242601的博客
05-19 201
多态、抽象类、接口 面向对象（多态的概述及其代码体现） A：多态（polymorphic）概述： 实物存在的多种形态 B：多态前提： a:要有继承关系。 b:要有方法重写。 c:要有父类引用指向子类对象。 C:案例演示 代码体现多态 class Demo1_Polymorphic {] public static void main (String[] args)...
2017.8.7
qq_21198501的博客
08-07 290
自己做的笔记没啥可看的
员工类案例演示
LeoZuosj的博客
02-04 353
员工类案例演示 class Test2_Employee{ public static void main(String[] args){ Employee ee = new Employee("令狐冲", "10001", 30000); ee.work(); } } /* * A:案例演示 * 需求:定义一个员工类Employee
抽象类与抽象方法的练习:编写一个Employee类，声明为抽象类，包含如下三个属性：name，id，salary。 提供必要的构造器和抽象方法：work()。 对于Manager类来说，他既是员工，还
YingxueSec
02-20 7293
编写一个Employee类，声明为抽象类， 包含如下三个属性：name，id，salary。 提供必要的构造器和抽象方法：work()。 对于Manager类来说，他既是员工，还具有奖金(bonus)的属性。 请使用继承的思想，设计CommonEmployee类和Manager类，要求类 中提供必要的方法进行属性访问 代码实现: /* 编写一个Employee类，声明为抽象类， 包含如下三个属性：name，id，salary。 提供必要的构造器和抽象方法：work()。 */ abstract class
6-5面向对象编程（下）----抽象类与抽象方法练习
wp_886的博客
01-30 1021
1.编写一个Employee类，声明为抽象类，包含如下三个属性：name，id，salary。 提供必要的构造器和抽象方法：work()。 对于Manager类来说，他既是员工，还具有奖金(bonus)的属性。 请使用继承的思想，设计CommonEmployee类和Manager类，要求类中提供必要的方法进行属性访问。 Mamager类： package exer3; public class Manager extends Employee { private double bonus;// 奖金
定义一个 Employee 雇员类，要求如下：(1) 属性有：id、name、salary(2) 运算符重载+：实现两个对象相加时，默认返回他们的薪水和
qq_26004719的博客
05-07 2236
class Employee: __init_flag=True def __init__(self,id,name,salary): self.id=id self.name=name self.salary=salary def __add__(self, other): if isinstance(other,Employee): return self.salary + othe...
接口，多态，抽象类，final
08-10
在 Java 编程语言中，接口、多态、抽象类和 final 是四个非常重要的概念，它们在面向对象编程（Object-Oriented Programming，OOP）中扮演着关键角色。 1. 接口 接口是 Java 中的一种特殊的抽象类，所有方法都是...
java中对象转型多态抽象类接口笔记.doc
06-28
### Java中的对象转型与多态 ...Java中的对象转型、多态、抽象类以及接口是面向对象编程的重要概念。通过这些机制，我们可以编写更加灵活、可扩展的代码。理解这些概念对于开发高质量的Java应用程序至关重要。
Python面向对象之接口、抽象类与多态详解
09-20
在探讨Python面向对象编程的过程中，接口、抽象类和多态是三个核心概念。理解这三个概念能够帮助我们在设计和实现软件时保持良好的可扩展性和复用性。 首先，接口在某些编程语言（比如Java）中是定义一个类必须实现...
day02-多态&抽象类&接口
06-11
day02-多态&抽象类&接口
Java抽象类接口与多态PPT教案学习.pptx
09-30
Java抽象类接口与多态PPT教案学习 Java抽象类接口与多态是Java编程语言的核心概念，本篇资源文件将详细介绍Java中的抽象类、接口和多态的概念、特点和应用。 一、抽象类 抽象类是Java中的一种特殊的类，它不能被...
C#某公司有各类员工，定义一个员工类（Employee），该类具有员工的姓名（Name）和基本薪金（Salary）等属性；并有一个虚方法（CalSalary）用于计算并输出员工的总薪金。
m0_68926878的博客
04-17 4393
、某公司有各类员工，定义一个员工类（Employee），该类具有员工的姓名（Name）和基本薪金（Salary）等属性；并有一个虚方法（CalSalary）用于计算并输出员工的总薪金。 对不同的员工，薪金的计算方法不同。 （1）定义一个继承自员工类的销售员类（SalesPerson），销售员除了员工类的基本薪金外，还有一个销售提成属性（SaleCommission）。现在在派生类中重新编写基类的虚方法（CalSalary），计算并输出销售员类的总薪金。 （2）定义一个计件工人类（PiecePerson
【Java学习】自定义类（以Employee类为例）
melon_sama的博客
11-16 468
直接上代码~ Main： import java.time.*; public class Main { public static void main(String[] args){ Employee[] staff=new Employee[3]; staff[0]=new Employee("Alice",10000,1987,12,15); staff[1]=new Employee("Bob",20000,1983,11,12);
Java面向对象编程
Kanteroa的博客
11-29 489
Java面向对象编程实验03
Java 抽象类
零一百
03-02 282
在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。 由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类
Java基础学习day14【谷】
m0_47711130的博客
07-20 1216
abstract不能去修饰方法和构造器abstract不能修饰静态方法、私有方法、final方法、final类。
java基础（6）- 面向对象（3）
KeepLearning的博客
12-04 306
6.1abstract抽象类 6.2接口 6.3问题总结；值传参，对象作为参数时的值传参
JAVA进阶补充
最新发布
2301_80150315的博客
08-15 928
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值