Java学习日志09（多态，抽象方法，抽象类，接口）
2019.12.20 0：22 心情： 困
09.01_面向对象(多态的概述及其特点)
-
A:多态的概述
- 事物存在的多种形态。
-
B:多态的前提
- 要有继承关系
- 要有方法重写
- 要有父类引用指向子类对象
package com.heima.polymorphic;
public class demo_01 {
public static void main(String[] args) {
Father f = new Son(); //父类引用指向子类对象
f.eat();
System.out.println(f.num);
f.sleep();
}
}
class Father {
int num = 10;
public static void sleep() {
System.out.println("爸爸睡觉了。");
}
public void eat() {
System.out.println("爸爸在哪里。");
}
}
class Son extends Father {
int num = 20;
public void eat() {
System.out.println("儿子去哪里。");
}
public static void sleep() {
System.out.println("儿子"
+ "睡觉了。");
}
}
09.02_面向对象(多态中的成员访问机器特点)(掌握)
-
成员变量
- 编译看作左边，运行看左边。
-
成员方法
- 编译看左边，运行看右边。
-
静态方法
- 编译看左边，运行看左边。（静态和类相关，算不上重写）
###09.03_面向对象(超人的故事)(掌握)
- 超人平时吃饭，睡觉，泡妞都是以人的形态，但是有困难就变成超人拯救世界。（编译看左边，运行看右边）。
09.04_面向对象(多态中的向上转型和向下转型)(掌握)
- Person p = new Superman(); //向上转型
- Superman sm = new Person(); //向下转型
package com.heima.polymorphic;
public class goodness_sadness {
public static void main(String args) {
method(new Cat());
method(new Dog());
}
public static void method(Animal a ) { //参数用多态，扩展性强
// 关键字 instanceof 判断前边的引用是不是后边的数据类型
if(a instanceof Cat) {
Cat c = (Cat)a; //向下转型
c.eat();
c.catching();
}else if (a instanceof Dog) {
Dog d = (Dog)a;//向下转型
d.eat();
d.look();
}else {
a.eat();
}
}
}
class Animal { //动物类
private String name; //类别
public void eat() {
System.out.println("吃东西。");
}
}
class Cat extends Animal { //猫类
public void eat() {
System.out.println("猫吃鱼。");
}
public void catching() {
System.out.println("猫抓老鼠。");
}
}
class Dog extends Animal { //狗类
public void eat() {
System.out.println("狗吃肉。");
}
public void look() {
System.out.println("狗看家。");
}
}
09.05_面向对象(多态的好处可弊端)(掌握)
- A:多态的好处
- 提高了代码的维护性（继承保证）
- 提高了代码的扩展性（多态保证）
可以作为形式参数，接收任意子类对象
- B:多态的弊端
- 不能使用子类的特有的属性和行为
- C:案例演示
*method(Animal a)
*method(Cat c)
开发中经常用：
父类中具备该方法，子类中重写该方法，将子类对象当作实际参数传入父类形式参数中
另外：如果要使用子类中特有的方法，就要进行强制类型转化。
09.06_面向对象(抽象类的概述及其特点)(掌握)
- A:抽象类概述
- 抽象就是看不懂的
- B:抽象类的特点
- 抽象类和抽象方法必须用abstract关键字修饰
- abstract class 类名 {}
- public abstract void eat()
- 抽象类不一定有抽象方法（父类是抽象类，子类继承抽象父类，没有重写父类中所有的抽象方法），但是有抽象方法一定是抽象类或者是接口。
- 抽象类不能被实例化，但是：根据多态的方式，由具体的子类实例化，其实这也是多态的一种，抽象类多态
*抽象类的子类：要么是抽象类，要么是重写类中的所有抽象方法。
09.07_面向对象(抽象类的成员特点)(掌握)
- A:抽象类的成员特点
- 成员变量：既可以是变量也可以是常量，abstract 不可以修饰成员变量
- b:构造方法： 有。
- 用于子类访问父类数据的初始化
- 成员方法： 可以是抽象的，抽象方法是强制要求子类做的事情。也可以是非抽象的，非抽象方法，子类继承的事情，提高代码复用性。
package com.heima.abstract_;
public class text_Animal {
public static void main(String[] args) {
}
}
abstract class Animal { //抽象的动物类
private String name ; //姓名
private int age ; //年龄
public Animal() { //空参构造
}
public Animal(String name,int age) { //有参构造
}
public abstract void eat(); //吃饭
}
class Cat extends Animal { //猫类
public void eat() {
}
}
09.08_面向对象(抽象类面试题)(掌握)
-
A:面试题1
- 一个抽象类如果没有抽象方法，可不可以定义为抽象？如果可以，有什么目的？
- 可以
- 这么做目的只有一个，就是不让其他类创建本类对象，交给子类完成
- 一个抽象类如果没有抽象方法，可不可以定义为抽象？如果可以，有什么目的？
-
B:面试题2
- a:abstract不可以和什么关键字共存
*abstract 和 static
被 abstract修饰的方法没有方法体
被static修饰的可以用类名.调用，但是类名.调用抽象方法是没有意义的。
*abstract和final
被abstract修饰的方法强制子类重写
被final修饰的方法不能被子类重写，所以他俩是矛盾。
abstract和private
被abstract修饰的方法强制子类访问和重写
private 修饰的方法不允许子类访问
- a:abstract不可以和什么关键字共存
package com.heima.abstract_;
public class text_emploee {
public static void main(String[] args) {
Coder c = new Coder("binge","1706200028",15000); //创建程序员对象
c.work();
Manager m = new Manager(); //创建经理对象
m.setName("zhuzhu");
m.setId("1706200000");
m.setSalary(20000);
m.setBonus(500);
m.work();
}
}
abstract class employee { //雇员类
private String name ; //名字
private String id; //工号
private int salary ; //工资
public employee() { //无参构造
}
public employee(String name, String id, int salary) { //有参构造
super();
this.name = name;
this.id = id;
this.salary = salary;
}
public String getName() {
return name;
}
public String getId() {
return id;
}
public int getSalary() {
return salary;
}
public void setName(String name) {
this.name = name;
}
public void setId(String id) {
this.id = id;
}
public void setSalary(int salary) {
this.salary = salary;
}
public abstract void work(); //计算工资方法
}
class Coder extends employee { //程序员类
public Coder() { //无参构造
super();
}
public Coder(String name, String id, int salary) {
super(name, id, salary);
}
@Override
public void work() {
System.out.println("我的名字是" + this.getName() + ",我的工号是"+this.getId() + ",我的工资是" + this.getSalary() + "我的工作敲代码。");
}
}
class Manager extends employee { //经理类
private int bonus; //奖金
public Manager() {
super();
// TODO Auto-generated constructor stub
}
public Manager(String name, String id, int salary,int bonus) {
super(name, id, salary);
this.bonus = bonus;
// TODO Auto-generated constructor stub
}
public int getBonus() {
return bonus;
}
public void setBonus(int bonus) {
this.bonus = bonus;
}
public void work() { //方法
System.out.println("我的姓名是" + this.getName() +",我的工号是" + this.getId() +",我的工资是" + this.getSalary()+ "我的奖金是" + this.getBonus()+"我的工作是管理。");
}
}
09.09_面向对象(接口的概述及其特点)(掌握)
- A:接口概述
- 从狭义的角度讲就是指Java中的interface
- 从广义的角度讲对外提供规则的都是接口
- B:接口特点
*a:接口用关键字interface表示
*interface 接口名{}
*b 类实现接口用implements 表示
* class 类名 implements 接口名 {}
*c 接口不可以实例化
*按照多态的方式进行实例化
*d 接口的子类
* 可以是抽象类，但是意义不大。
* 可以是具体类，但是有重写接口中的所有抽象方法
package com.heima.interface_;
public class demo1 {
public static void main (String[] args) {
Demo_1 d1 = new Demo_1();
d1.print1();
d1.print2();
}
}
interface Inter1 {
public static final int N1 = 10;
public abstract void print1();
}
interface Inter2 {
public static final int N2 = 20;
public abstract void print2();
}
class Demo_1 implements Inter1,Inter2 {
public void print1() {
System.out.println(N1);
}
public void print2() {
System.out.println(N2);
}
}
interface Inter3 extends Inter1,Inter2 {
}
09.10_面向对象(接口成员特点)(掌握)
-
A:成员变量
- 只能是常量，并且是静态的并且公共的public
- 默认修饰符： public static final
- 建议自己给出
-
B:构造方法
*接口没有构造方法 -
C:成员方法：
- 只能是抽象方法
- 默认修饰符：public abstract
- 建议自己手动给出
package com.heima.interface_;
public class Text_Animal {
public static void main(String[] args) {
// TODO Auto-generated method stub
Cat c = new Cat();
c.eat();
c.sleep();
c.jump();
}
}
abstract class Animal {
private String name ; //名字
private String colour; //毛色
private int age ; //年龄
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public String getColour() {
return colour;
}
public void setName(String name) {
this.name = name;
}
public void setColour(String colour) {
this.colour = colour;
}
public abstract void eat();
public abstract void sleep();
}
interface Inter {
public abstract void jump();
}
class Cat extends Animal implements Inter {
public void eat() {
System.out.println("猫吃鱼。");
}
public void sleep() {
System.out.println("睡沙发。");
}
public void jump() {
System.out.println("跳屋顶。");
}
}
09.11_面向对象(类与类，类与接口，接口与接口)(掌握)
- A 关系：
- 类与类：
- 继承关系，只能单继承，不可以多层继承。
- 类与类：
- B:类与接口：
- 实现关系： 可以单实现，也可以多实现。
- 并且还可以在继承一个类的同时实现多个接口
- C: 接口与接口：
- 继承关系： 可以单继承，也可以多继承。
09.14_面向对象(抽象类和接口的区别)(掌握)
-
A:成员区别
- 抽象类：
- 成员变量：可以变量，也可以常量
- 构造方法： 有
- 成员方法：可以抽象，也可以非抽象
- 接口：
- 成员变量只能是常量 public static final
- 成员方法： 只可以是抽象public abstract
-
B:关系区别
- 类与类
- 继承，单继承
- 类与接口
- 实现，单实现，多实现
*接口与接口 - 继承，单继承，多继承
- 实现，单实现，多实现
- 类与类
-
C： 设计理念区别
- 抽象类 被继承体现的是； “is a ”的关系，抽象类中定义的是该基层体系的共性功能
- 接口 被实现体现的是： “like a” 的关系，接口中定义的是该继承体系的扩展功能。
09.15_面向对象(方法重写的面试题)(掌握)
- A:方法重写的面试题
- Override和Overload的区别?Overload能改变返回值类型吗?
- overload（重载）可以改变返回值类型,只看参数列表
- 方法重写：子类中出现了和父类中方法声明一模一样的方法。与返回值类型有关,返回值是一致(或者是子父类)的
- 方法重载：本类中出现的方法名一样，参数列表不同的方法。与返回值类型无关。
- 子类对象调用方法的时候：（就近原则）
- 先找子类本身，再找父类。
09.16_面向对象(使用继承前的学生和老师案例)(掌握)
- A:案例演示
- 使用继承前的学生和老师案例
- 属性:姓名,年龄
- 行为:吃饭
- 老师有特有的方法:讲课
- 学生有特有的方法:学习
0917_面向对象(使用继承后的学生和老师案例)(掌握)
- A:案例演示
- 使用继承后的学生和老师案例
09.18_面向对象(猫狗案例分析,实现及测试)(掌握)
- A:猫狗案例分析
- B:案例演示
- 猫狗案例继承版
- 属性:毛的颜色,腿的个数
- 行为:吃饭
- 猫特有行为:抓老鼠catchMouse
- 狗特有行为:看家lookHome
09.19_面向对象(final关键字修饰类,方法以及变量的特点)(掌握)
- A:final概述
- B:final修饰特点
- 修饰类，类不能被继承
- 修饰变量，变量就变成了常量，只能被赋值一次
- 修饰方法，方法不能被重写
09.20_面向对象(final关键字修饰局部变量)(掌握)
- A:案例演示
-
方法内部或者方法声明上都演示一下(了解)
(1)方法声明上使用（形参）后，可以反复调用该方法，因为每次调用方法后，都会弹栈，下次再次调用是新的方法。 -
基本类型，是值不能被改变
-
引用类型，是地址值不能被改变,对象中的属性可以改变
-
09.21_面向对象(final修饰变量的初始化时机)(掌握)
- A:final修饰变量的初始化时机
- 显示初始化
- 在对象构造完毕前即可
两者只能用其一。