JAVA语言基础-面向对象(抽象类，包，内部类）

最新推荐文章于 2024-07-21 22:23:56 发布

weixin_34365417

最新推荐文章于 2024-07-21 22:23:56 发布

阅读量229

点赞数

文章标签： java 面试 python

原文链接：https://my.oschina.net/u/3668429/blog/1928086

版权

2019独角兽企业重金招聘Python工程师标准>>>

面向对象(抽象类的概述及其特点)

A:抽象类概述
- 抽象就是看不懂的
B:抽象类特点
- a:抽象类和抽象方法必须用abstract关键字修饰
  - abstract class 类名 {}
  - public abstract void eat();
- b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口
- c:抽象类不能实例化那么，抽象类如何实例化呢?
  - 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
- d:抽象类的子类
  - 要么是抽象类
  - 要么重写抽象类中的所有抽象方法
C:案例演示
- 抽象类特点B:抽象类特点
- a:抽象类和抽象方法必须用abstract关键字修饰
  - abstract class 类名 {}
  - public abstract void eat();
- b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口
- c:抽象类不能实例化那么，抽象类如何实例化呢?
  - 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
- d:抽象类的子类
  - 要么是抽象类
  - 要么重写抽象类中的所有抽象方法

class Demo1_Abstract {
	public static void main(String[] args) {
		//Animal a = new Animal();			//错误: Animal是抽象的; 无法实例化
		Animal a = new Cat();				//父类引用指向子类对象
		a.eat();
	}
}
/*
* B:抽象类特点
	* a:抽象类和抽象方法必须用abstract关键字修饰
		* abstract class 类名 {}
		* public abstract void eat();
	* b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口
	* c:抽象类不能实例化那么，抽象类如何实例化呢?
		* 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
	* d:抽象类的子类
		* 要么是抽象类
		* 要么重写抽象类中的所有抽象方法
*/
abstract class Animal {						//抽象类
	public abstract void eat();				//抽象方法

	public Animal() {
		System.out.println("父类空参构造");
	}
}

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

面向对象(抽象类的成员特点)

A:抽象类的成员特点
- a:成员变量：既可以是变量，也可以是常量。abstract是否可以修饰成员变量?不能修饰成员变量
- b:构造方法：有。
  - 用于子类访问父类数据的初始化。
- c:成员方法：既可以是抽象的，也可以是非抽象的。
B:案例演示
- 抽象类的成员特点
C:抽象类的成员方法特性：
- a:抽象方法强制要求子类做的事情。
- b:非抽象方法子类继承的事情，提高代码复用性。

class Demo2_Abstract {
	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
}

/*
* A:抽象类的成员特点
	* a:成员变量：既可以是变量，也可以是常量。abstract是否可以修饰成员变量?不能修饰成员变量
	* b:构造方法：有。
		* 用于子类访问父类数据的初始化。
	* c:成员方法：既可以是抽象的，也可以是非抽象的。
* B:案例演示
	* 抽象类的成员特点
* C:抽象类的成员方法特性：
	* a:抽象方法 强制要求子类做的事情。
	* b:非抽象方法 子类继承的事情，提高代码复用性。
*/

abstract class Demo {
	int num1 = 10;
	final int num2 = 20;

	public Demo(){}

	public void print() {
		System.out.println("111");
	}

	public abstract void method();
}

class Test extends Demo {
	public void method() {
		System.out.println("111");
	}
}

面向对象(葵花宝典)

案例演示
- 抽象类的作用

class Demo3_葵花宝典 {
	public static void main(String[] args) {
		岳不群 小岳子 = new 岳不群();
		小岳子.自宫();
	}
}

abstract class 葵花宝典 {
	public abstract void 自宫();
}

class 岳不群 extends 葵花宝典 {
	public void 自宫() {
		System.out.println("用牙签");
	}
}

class 林平之 extends 葵花宝典 {
	public void 自宫() {
		System.out.println("用指甲刀");
	}
}

class 东方不败 extends 葵花宝典 {
	public void 自宫() {
		System.out.println("用锤子,不忍直视");
	}
}

面向对象(抽象类练习猫狗案例)

A:案例演示
- 具体事物：猫，狗
- 共性：姓名，年龄，吃饭
- 猫的特性:抓老鼠
- 狗的特性:看家

class Test1_Animal {
	public static void main(String[] args) {
		Cat c = new Cat("加菲",8);
		System.out.println(c.getName() + "..." + c.getAge());
		c.eat();
		c.catchMouse();

		Dog d = new Dog("八公",30);
		System.out.println(d.getName() + "..." + d.getAge());
		d.eat();
		d.lookHome();
	}
}
/*
* A:案例演示
	* 具体事物：猫，狗
	* 共性：姓名，年龄，吃饭
	* 猫的特性:抓老鼠
	* 狗的特性:看家
*/
abstract class Animal {
	private String name;				//姓名
	private int age;					//年龄

	public Animal(){}					//空参

	public Animal(String name,int age) {//有参
		this.name = name;
		this.age = age;
	}

	public void setName(String name) {	//设置姓名
		this.name = name;
	}

	public String getName() {			//获取姓名
		return name;
	}

	public void setAge(int age) {		//设置年龄
		this.age = age;
	}

	public int getAge() {				//获取年龄
		return age;
	}

	public abstract void eat();			//吃饭
}

class Cat extends Animal {
	public Cat(){}					//空参

	public Cat(String name,int age) {//有参
		super(name,age);
	}

	public void eat() {
		System.out.println("猫吃鱼");
	}

	public void catchMouse() {
		System.out.println("抓老鼠");
	}
}

class Dog extends Animal {
	public Dog(){}					//空参

	public Dog(String name,int age) {//有参
		super(name,age);
	}

	public void eat() {
		System.out.println("狗吃肉");
	}

	public void lookHome() {
		System.out.println("看家");
	}
}

面向对象(抽象类练习老师案例)

A:案例演示
- 具体事物：基础班老师，就业班老师
- 共性：姓名，年龄，讲课。
- 具体事物:基础班学生,就业班学生
- 共性:姓名,年龄,学习

class Test2_Teacher {
	public static void main(String[] args) {
		BaseTeacher bt = new BaseTeacher("冯佳",18);
		bt.teach();
	}
}
/*
* 具体事物：基础班老师，就业班老师
	* 共性：姓名，年龄，讲课。
*/

abstract class Teacher {
	private String name;				//姓名
	private int age;					//年龄

	public Teacher(){}					//空参

	public Teacher(String name,int age) {//有参
		this.name = name;
		this.age = age;
	}

	public void setName(String name) {	//设置姓名
		this.name = name;
	}

	public String getName() {			//获取姓名
		return name;
	}

	public void setAge(int age) {		//设置年龄
		this.age = age;
	}

	public int getAge() {				//获取年龄
		return age;
	}

	public abstract void teach();
}

class BaseTeacher extends Teacher {
	public BaseTeacher(){}					//空参

	public BaseTeacher(String name,int age) {//有参
		super(name,age);
	}

	public void teach() {
		System.out.println("我的姓名是:" + this.getName() + ",我的年龄是:" + this.getAge() + ",讲的内容是java基础");
	}
}

面向对象(抽象类练习员工案例)

A:案例演示
- 假如我们在开发一个系统时需要对程序员类进行设计，程序员包含3个属性：姓名、工号以及工资。
- 经理，除了含有程序员的属性外，另为还有一个奖金属性。
- 请使用继承的思想设计出程序员类和经理类。要求类中提供必要的方法进行属性访问。

class Test3_Employee {
	public static void main(String[] args) {
		Coder c = new Coder("德玛西亚","007",8000);
		c.work();

		Manager m = new Manager("苍老师","9527",3000,20000);
		m.work();
	}
}
/*
* 假如我们在开发一个系统时需要对程序员类进行设计，程序员包含3个属性：姓名、工号以及工资。
	* 经理，除了含有程序员的属性外，另为还有一个奖金属性。
	* 请使用继承的思想设计出程序员类和经理类。要求类中提供必要的方法进行属性访问。
*/

abstract class Employee {
	private String name;					//姓名
	private String id;						//工号
	private double salary;					//工资

	public Employee() {}					//空参构造

	public Employee(String name,String id,double salary) {
		this.name = name;
		this.id = id;
		this.salary = salary;
	}

	public void setName(String name) {		//设置姓名
		this.name = name;
	}

	public String getName() {				//获取姓名
		return name;
	}

	public void setId(String id) {			//设置id
		this.id = id;
	}

	public String getId() {					//获取id
		return id;
	}

	public void setSalary(double salary) {	//设置工资
		this.salary = salary;
	}

	public double getSalary() {				//获取工资
		return salary;
	}

	public abstract void work();
}

//程序员
class Coder extends Employee {
	public Coder() {}					//空参构造

	public Coder(String name,String id,double salary) {
		super(name,id,salary);
	}

	public void work() {
		System.out.println("我的姓名是:" + this.getName() + ",我的工号是:" + this.getId() + ",我的工资是:" 
			+ this.getSalary() + ",我的工作内容是敲代码");
	}
}

//项目经理
class Manager extends Employee {
	private int bonus;					//奖金
	public Manager() {}					//空参构造

	public Manager(String name,String id,double salary,int bonus) {
		super(name,id,salary);
		this.bonus = bonus;
	}

	public void work() {
		System.out.println("我的姓名是:" + this.getName() + ",我的工号是:" + this.getId() + ",我的工资是:" 
			+ this.getSalary() + ",我的奖金是:" + bonus + ",我的工作内容是管理");
	}
}

面向对象(抽象类中的面试题)

A:面试题1
- 一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
- 可以
- 这么做目的只有一个,就是不让其他类创建本类对象,交给子类完成
B:面试题2
- abstract不能和哪些关键字共存

class Demo4_Abstract {
	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
}
/*
* A:面试题1
	* 一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
	* 可以
	* 这么做目的只有一个,就是不让其他类创建本类对象,交给子类完成
* B:面试题2
	* abstract不能和哪些关键字共存
	1.abstract和static
	被abstract修饰的方法没有方法体
	被static修饰的可以用类名.调用,但是类名.调用抽象方法是没有意义的
	2.abstract和final
	被abstract修饰的方法强制子类重写
	被final修饰的不让子类重写,所以他俩是矛盾
	3.abstract和private
	被abstract修饰的是为了让子类看到并强制重写
	被private修饰不让子类访问,所以他俩是矛盾的
*/

abstract class Demo {
	//public static abstract void print();		//错误: 非法的修饰符组合: abstract和static
	//public final abstract void print();		//错误: 非法的修饰符组合: abstract和final
	private abstract void print();				//错误: 非法的修饰符组合: abstract和private
}