抽象类的概念和讲解

最新推荐文章于 2022-10-16 23:04:55 发布
最新推荐文章于 2022-10-16 23:04:55 发布
阅读量507 收藏
点赞数 1
分类专栏： Java基础篇
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41959763/article/details/79948409
版权 
/*
	抽象类的概述：
		动物不应该定义为具体的东西，而且动物中的吃，睡等也不应该是具体的。
		我们把一个不是具体的功能称为抽象的功能，而一个类中如果有抽象的功能，该类必须是抽象类。
		
	抽象类的特点：
		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是抽象的; 无法实例化
		//Animal a = new 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);
		//a.num2 = 200;
		System.out.println(a.num2);
		System.out.println("--------------");
		a.show();
		a.method();
	}
}

/*
一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
	A:可以。
	B:不让创建对象。

abstract不能和哪些关键字共存?
	private	冲突
	final	冲突	
	static	无意义
*/
abstract class Fu {
	//public abstract void show();
	//非法的修饰符组合: abstract和private
	//private abstract void show();
	
	//非法的修饰符组合
	//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();
	}
}
/*
	猫狗案例
		具体事物：猫，狗
		共性：姓名，年龄，吃饭

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




weixin_41959763
关注
专栏目录
2019新版35 U.S.C. 101专利适格性审查指南　新增「抽象概念三分类」及「整合至实际应用」判定标准
Johnny的专利漫谈空间
02-17 4187
  2019年才刚开始几天，美国专利及商标局(USPTO)就给出了一个新年大贺礼 - 35 U.S.C. 101专利适格性审查指南，这也是大家引颈期盼已久、希望能让抽象概念的认定更为明确的一份指导文件。在此指南中，主要是针对了Alice/Mayo案所确立的适格性测试两步法中的Step 2A进行修订，将其明确拆分为两部份：判断一(Prong One)以及判断二(Prong Two)，其中又...
Java抽象类的概念讲解
08-26
Java抽象类的概念讲解 Java抽象类是Java编程语言中的一种基本概念，它们提供了一种方式来定义一个类族的共同特征和行为。抽象类是不能被实例化的类，它们的目的就是被继承和扩展。 抽象类的定义 抽象类是使用...
面向对象-抽象类
兴趣是最好的老师
05-06 1097
抽象类的特点： /* 抽象类的概述： 动物不应该定义为具体的东西，而且动物中的吃，睡等也不应该是具体的。 我们把一个不是具体的功能称为抽象的功能，而一个类中如果有抽象的功能，该类必须是抽象类。 抽象类的特点： A:抽象类和抽象方法必须用abstract关键字修饰 B:抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类 C:抽象类不能实例化 因为它
抽象类的讲解
zyz的博客
11-06 173
1.抽象类概述 一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类 使用抽象类就可以确保子类都必须实现父类的抽象方法（就是父类想让子类单独实现的方法），否则就会报错 2.抽象类的特点 Animal a=new Cat(); a.sleep();//这个sleep是Animal里的普通方法不是抽象方法，可以实例化后调用 3.抽象类的成员特点 抽象类的实例化时通过子类来进行实例化的 ...
抽象类的概念
最新发布
m0_70336653的博客
10-16 102
1.1 抽象类的概念。
抽象类
gafeng123456的博客
02-03 360
抽象类的概述 动物不应该定义为具体的东西，而且动物中的吃，睡等也不应该是具体的。 我们把一个不是具体的功能称为抽象的功能，而一个类中如果有抽象的功能，该类必须是抽象类。 抽象类的特点 A:抽象类和抽象方法必须用abstract关键字修饰 B:抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类 C:抽象类不能实例化 因为它不是具体的。
C# 抽象类,抽象属性,抽象方法(实例讲解)
08-28
C# 抽象类、抽象属性、抽象方法实例讲解 C# 抽象类是面向对象编程（OOP）中的一种重要概念，用于描述一系列看上去不同，但是本质上相同的具体概念的抽象。抽象类可以包含抽象属性和抽象方法，子类必须override这些...
Qt/C++抽象类和纯虚函数讲解示例源代码
07-02
该资源是博主博客的源代码，博客上有详细讲解Qt/C++关于纯虚函数和抽象基类原理讲解和示例用法解释，博客地址如下： https://blog.csdn.net/naibozhuan3744/article/details/94488200 其中编译环境为QtCreator4.5.0...
C#抽象类和接口的区别分析
01-01
很多C#的初学者在编程时都容易把抽象类和接口搞混,本文就为大家从概念上讲解抽象类和接口的区别： 一、抽象类： 含有abstract修饰符的class即为抽象类，抽象类是特殊的类，只是不能被实例化，可以创建一个变量，其...
抽象类讲解
chuoqun2406的博客
06-07 135
声明:没有方法体的方法. * * abstract:抽象的 * 抽象类和抽象方法 * 抽象方法:被abstract修饰的方法.方法的特点是:只有方法的声明没有实现. * 抽象类:在继承中,提取父类方法的时候,每个子类都有自己的具体实现方式,而...
Java abstract
u013934107的博客
08-18 3848
/* abstract:是一个修饰符 可以修饰方法，类 1.当我们多个类存在相同的功能，但是功能的主体不同，这时我们进行向上抽取 只抽取功能的定义不抽取功能的主体 抽象类的特点： 1.抽象方法一定要在抽象类中 2.抽象类和抽象方法必须要被abstract关键字修饰 3.抽象的类是不能被创建对象，因为调用抽象的方法没意义 4.抽象类中的方法要被使用，必须由子类重写抽象类中的方法 然后创建子类对象来调...
阿里Java学习路线：阶段 1：Java语言基础－Java面向对象编程：第18 章 ： 抽象类的定义与使用：课时82：抽象类基本概念
Kenny C
06-29 222
类继承的主要作用在于可以扩充已有类的功能，但是对于之前的继承操作而言会发现，子类可以由自己选择任意来决定是否要覆写某一个方法，这个时候父类无法对子类做出强制性约定（强制性必须覆写某些方法），这种情况下往往不会采用类的继承（在实际的开发之中很少会出现继承一个已经完善的类，可以直接使用的类）而是必须要继承抽象类，在以后进行父类（SuperClass）设计的时候优先考虑的一定是抽象类。 抽象类的基本定义 抽象类的主要作用在于对子类中覆写方法进行约定，在抽象类里面可以去定义一些抽象方法以实现这样的约定，抽象方法指的
抽象类详解
rolic_的博客
05-04 347
package test9;/* * 1.如何定义抽象类？ * class关键字前加abstract * 2.抽象类无法被实例化，也就是无法创建对象 * 3.虽然抽象类没有办法实例化，但抽象类也有构造方法，该构造方法是给子类创建对象用的，一般会用到继承和多态 * 4.抽象类可以定义抽象方法： * 抽象方法的语法：在方法的修饰符列表中添加abstract关键字，并且抽象方法应该以;结束，而不...
抽象类的详解
weixin_55079859的博客
06-23 6993
抽象类的详解
抽象方法和抽象类
weixin_30426957的博客
03-06 88
·抽象方法 使用abstract修饰的方法，没有方法体，只有声明。定义的是一种“规范”，就是告诉子类必须要给抽象方法提供具体的实现。 ·抽象类 包含抽象方法的类就是抽象类。通过abstract方法定义规范，然后要求子类必须定义具体实现。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。 【示例5-16】抽象类和抽象方法的基本用法 package...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值