黑马程序员—JAVA基础—多态、抽象类、接口、修饰符

最新推荐文章于 2024-04-09 12:27:45 发布

gxf13283606362

最新推荐文章于 2024-04-09 12:27:45 发布

阅读量341

点赞数

本文链接：https://blog.csdn.net/gxf13283606362/article/details/50063001

版权

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

一、多态

1、概念：

同一个对象在不同时刻体现出来的不同状态。

2、多态的前提：

A：有继承或者实现关系。

B：有方法重写。

C：有父类或者父接口引用指向子类对象。

3、多态的分类：

A：具体类多态

B：抽象类多态

C：接口多态

4、多态中的成员访问特点：

A：成员变量

编译看左边，运行看左边

B：构造方法：

子类的构造都会默认访问父类构造

C：成员方法：

编译看左边，运行看右边

D：静态方法：

编译看左边，运行看左边

5、多态的优点：

A：提高代码的维护性(继承体现)

B：提高代码的扩展性(多态体现)

6、多态的缺点：

A：父不能使用子的特有功能。

现象：子可以当作父使用，父不能当作子使用。

7、多态中的转型：

A：向上转型：从子到父

B：向下转型：从父到子

Eg：

/*
	看程序写结果:先判断有没有问题，如果没有，写出结果
	
	多态的成员访问特点：
		方法：编译看左边，运行看右边。
		
	继承的时候：
		子类中有和父类中一样的方法，叫重写。
		子类中没有父亲中出现过的方法，方法就被继承过来了。
*/
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();
	}
}</span>

二、抽象类

1、概念：

用关键字abstract修饰的类称为抽象类.

注意事项：

A：而一个没有具体的方法体的方法是抽象的方法。

B：在一个类中如果有抽象方法，该类必须定义为抽象类。

2、抽象类的特点

A：抽象类和抽象方法必须用关键字abstract修饰

B：抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类

C：抽象类不能实例化

D：抽象类的子类

a：可以是一个抽象类。

b：可以是一个具体类。但是这个类必须重写抽象类中的所有抽象方法。

3、抽象类的成员特点：

A：成员变量

有变量，有常量

B：构造方法

有构造方法

C：成员方法

有抽象，有非抽象

4、注意事项：

A:抽象类有构造方法，不能直接实例化，通过子类间接实例化。

B：一个类如果没有抽象方法,却定义为了抽象类，作用：为了不让创建对象

C：abstract不能和哪些关键字共存

a：final 冲突

b：private 冲突

c：static 无意义

Eg：

/*
	假如在开发一个系统时需要对员工类进行设计，员工包含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();
	}
}

三、:接口

1、概述：

接口可以理解成一种特殊的类，是由用final修饰的常量（自定义常量）和公共的抽象方法组成的类；

2：接口的特点：

A：接口用关键字interface修饰

interface 接口名 {}

B：类实现接口用implements修饰

class 类名 implements 接口名 {}

C：接口不能实例化

D：接口的实现类

a：可以是一个抽象类。

b：可以是一个具体类，这个类必须重写接口中的所有抽象方法。

3、接口的成员特点：

A：成员变量

a: 只能是常量

b: 默认修饰符：public static final

B：构造方法

没有构造方法

C：成员方法

a: 只能是抽象的

b: 默认修饰符：public abstract

4、类与类,类与接口,接口与接口

A：类与类

继承关系，只能单继承，可以多层继承

B：类与接口

a：实现关系，可以单实现，也可以多实现。

b：可以在继承一个类的同时，实现多个接口

C：接口与接口

继承关系，可以单继承，也可以多继承

Eg：

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

		部分老师抽烟：实现抽烟接口
		部分学生抽烟：实现抽烟接口
		
	实现：从抽象到具体
		
	使用：具体
*/
//定义抽烟接口
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("李四",28);
		System.out.println(ss2.getName()+"---"+ss2.getAge());
		ss2.eat();
		ss2.sleep();
		ss2.smoke();
	}
}</span>

四、抽象类和接口的区别

A：成员区别

抽象类：可以使常量；也可以是变量

接口：只能是用final修饰的常量

B：关系区别：

类与类： a：可以是一个抽象类。

b：可以是一个具体类。但是这个类必须重写抽象类中的所有抽象方法。

类与接口： a：实现关系，可以单实现，也可以多实现。

b：可以在继承一个类的同时，实现多个接口

接口与接口：继承关系，可以单继承，也可以多继承

C：设计理念不同

抽象类：is a，抽象类中定义的是共性功能。

接口：like a，接口中定义的是扩展功能。

五、常见的修饰符

A：分类：

权限修饰符：private,默认,protected,public

状态修饰符：static,final

抽象修饰符：abstract

B：常见的类及其组成的修饰

类：默认,public,final,abstract

常用的：public

成员变量： private,默认,protected,public,static,final

常用的： private

构造方法： private,默认,protected,public

常用的： public

成员方法： private,默认,protected,public,static,final,abstract

常用的： public

C：另外比较常见的：

public static final int X = 10;

public static void show() {}

public final void show() {}

public abstract void show();

七、权限修饰符

(Y代表可以访问)

	本类	同一个包下	不同包下的子类	不同包下的无关类
private	Y
默认	Y	Y
protected	Y	Y	Y
public	Y	Y	Y	Y

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

gxf13283606362

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员—JAVA基础—多态、抽象类、接口、修饰符

一、多态 1、概念：同一个对象在不同时刻体现出来的不同状态。 2、多态的前提： A：有继承或者实现关系。 B：有方法重写。 C：有父类或者父接口引用指向子类对象。 3、多态的分类： A：具体类多态 B：抽象类多态
复制链接

扫一扫