Java基础_基础语法知识9
面向对象
1.面向对象抽象类
(1).抽象类概述
什么是抽象类？所谓的抽象类就是抽象的，如动物，人，自然等这些都是抽象的，只有我们说到具体的一个东西，如猫，狗
学生小明，树木等，我们才知道是一个什么东西。那么在java语言中，一个没有方法体的方法就该定义为抽象方法，而一个类
中如果有抽象方法，那么这一个类就必须定义为抽象类。
(2).抽象类的特点
A:抽象类和抽象方法必须使用关键字abstract来修饰，具体用法如下:
[权限修饰符] abstract class 类名{}
B:抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类
C:抽象类不能够实例化
因为它不是具体的。
抽象类有构造方法，但是不能够用于创建对象。其主要是用于子类访问父类数据的初始化。
D:抽象类的子类
a:如果不想重写抽象方法，该子类是一个抽象类。
b:重写所有的抽象方法，这一个时候子类是一个具体的类。
抽象类的实例化其实是通过子类来实现的，也就是一个多态的体现。
Animal a = new Cat();
(3).一个抽象类的测试代码
//抽象类
public abstract class Animal {
//抽象方法没有具体的方法体
public abstract void eat();
public abstract void sleep();
public Animal(){}
}
//抽象类子类
publi abstract Cat extends Animal{}
//具体子类
public class Dog extends Animal{
//子类重写抽象方法，这一个时候子类是一个具体的类
public void eat(){
System.out.println("小狗要吃肉");
}
public void sleep(){
System.out.println("小狗睡觉");
}
//测试
public static void main(String[] args) {
Animal a = new Dog();
a.eat();
a.sleep();
}
}
//注意事项:具体子类如果重写了父类的方法，那么就必须要重写所有的方法，哪怕是给出空方法体。
把父类作为一个抽象类给子类，其实这也是一个多态的体现。
(4).抽象类的成员特点
A:成员变量
可以是变量，也可以是常量，和一般的类一样。
B:构造方法
有，用于子类访问父类的初始化数据。
C:成员方法
既可以是抽象的，也可以不是抽象的。
可见抽象类的成员方法的特性:[*****]
A:抽象方法 强制要求子类要做的事情。
B:非抽象的方法 子类继承的事情，可以提高代码的复用性。
(5).一个抽象类代码:[*****]
//抽象类
public 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 class Dog extends Animal{
public Dog(){}
public Dog(String name,int age){
super(name,age);
}
//重写父类方法
public void eat(){
System.out.println("小狗吃肉");
}
//测试
public static void main(String[] args) {
//-------方法1-----------
Dog d = new Dog();
d.setName("二哈");
d.setAge(12);
System.out.println(d.getName()+"----"+d.getAge());
//--------方法2-----------
Dog d1 = new Dog("胖二哈",13);
d1.eat();
System.out.println(d1.getName()+"-----"+d1.getAge());
//---------方法3---------
Animal a = new Dog();
a.setName("特胖二哈");
a.setAge(14);
System.out.println(a.getName()+"----"+a.getAge());
}
}
//输出结果:
二哈----12
小狗吃肉
胖二哈-----13
特胖二哈----14
2.面向对象接口
(1).接口概述
为了更好的体现一个事务的扩展性，所以，我们在抽象类中定义一些额外的功能，但是并不给出一个具体的实现，java中给了接口用于
定义这一些扩展功能。
(2).接口的特点
A:接口要使用关键字interface来定义；
具体：interface 接口名{}
B:如何使用这一个接口
类实现接口使用implement表示；
如:class 类名 implement 接口名{}
C:接口不能够实例化
那么？接口不能够实例化？
按照多态的方式来
D：接口的子类
a:可以是抽象类，但是意义不大
b:可以是具体类，但是要重写接口中的所有抽象方法。
由此可见:
具体类多态(几乎没有)
抽象类多态(常用)
接口多态(最常用)
(3).接口成员特点
成员变量:只能够是常量，并且还是静态的
存在着默认修饰符:public static final
构造方法：接口没有构造方法，无法使用构造方法。
成员方法：只能够使抽象方法
存在默认修饰符 public abstract
建议手动给出修饰符
(4).类与类，类与接口之间的关系
类与类
继承关系，只能够是单继承，可以是多层继承。
类与接口
可以是实现关系，可以是单实现，也可以是多实现
并且还可以再继承一个类的时候实现多接口
如:class Son implements Father,Mother{}
接口与接口
继承关系，可以单继承，也可以多继承。
(5).抽象了与接口之间的区别
抽象类和接口的区别：
A:成员区别
抽象类：
成员变量：可以变量，也可以常量
构造方法：有
成员方法：可以抽象，也可以非抽象
接口：
成员变量：只可以常量
成员方法：只可以抽象
B:关系区别
类与类
继承，单继承
类与接口
实现，单实现，多实现
接口与接口
继承，单继承，多继承
C:设计理念区别
抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。
3.面向对象抽象类，接口，多态综合案例
/*
老师和学生案例,加入抽烟的额外功能
分析：从具体到抽象
老师：姓名，年龄，吃饭，睡觉
学生：姓名，年龄，吃饭，睡觉
由于有共性功能，我们提取出一个父类，人类。
人类：
姓名，年龄
吃饭();
睡觉(){}
抽烟的额外功能不是人或者老师，或者学生一开始就应该具备的，所以，我们把它定义为接口
抽烟接口。
部分老师抽烟：实现抽烟接口
部分学生抽烟：实现抽烟接口
实现：从抽象到具体
使用：具体
*/
//定义抽烟接口
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();
//测试老师留给自己练习
}
}
