封装、继承、多态、重载、重写、接口、抽象类
文章目录
怎么理解面向对象？
- 对于什么是面向对象，它是一种编程思想。聊到面向对象，我们需要聊一下面向过程的编程方式，因为面向对象是从面向过程过渡而来的。
以实际生活的案例来举一个例子，比如说洗衣服。 如果是面向过程的话，我们会将这个洗衣服任务拆解成一系列的步骤，每一个步骤就是一个函数。
面向过程：把衣服脱下来–>找一个盆–>放点洗衣粉–>加点水–>浸泡10分钟–>揉一揉–>清洗衣服–>拧干–>晾起来
如果是面向对象的编程方式，我们会拆分成人和洗衣机两个对象，再分析每一个对象，它需要做哪些事情。
面向对象：把衣服脱下来–>打开全自动洗衣机–>扔衣服–>按钮–>晾起来 洗衣机在其中只需要做一件事情：根据洗衣模式洗衣服。
在这个例子中，我们能够看出来面向过程跟面向对象，是两种不同的思维方式，处理问题的思考的角度不一样。
- 面向过程的思维方式，它更加注重这个事情的每一个步骤以及顺序。他比较直接高效，需要做什么可以直接开始干。
- 面向对象的思维方式，它更加注重事情有哪些参与者，需求里面有哪些对象，这些对象各自需要做些什么事情。将其拆解成一个个模块和对象，这样会更易于维护和拓展。
面向对象有什么特征？封装、继承和多态
面向对象的第一大特性：封装
- 概念：通过访问修饰符（如 private）来修饰成员变量和成员方法，将不需要对外提供的内容都隐藏起来，提供公共方法(getter setter)对其访问。
- 优点：隐藏实现细节，提供公共的访问方式；提高了代码的复用性；提高安全性
- 意义：将内部的实现细节隐藏起来，对外部的调用者来说是透明的，调用者也不用关心它内部是怎么实现的，只需要知道这个方法是干什么的就好。
面向对象的第二大特性：继承
- 概念：在 Java 中子类使用关键词
extend去继承父类的关系。 - 用途：将子类存在共性的东西，把它抽取出来放到父类里面，比如将共同拥有的属性和方法抽取出来放到父类里面。
- 好处：想要使用这些属性和方法的时候，可以直接去使用父类的，而不需要自己再重新去定义，更大程度的实现代码复用。我们不需要写很多的冗余的代码，把共性的全部抽到父类，可以直接调用，如果需要个性化自定义子类的方法时，去重写父类的方法即可，提供了拎一个特征多态的前提。
面向对象的第三大特性：多态
- 概念：多态是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口，使用不同的实例而执行不同操作
理解：多态是和继承一脉相承的，多态存在的需要有三个必要条件：继承、重写、父类引用指向子类对象（Parent p = new Child()）。
用个案例再补充解释一下： 比如说打印机，它属于一个父类，有一台彩色打印机，属于子类，有一台黑白打印机，也属于子类。
继承，彩色打印机和黑白打印机都继承自打印机这个父类；
重写，打印机有一个打印的方法，彩色打印机和黑白打印机会重写父类的打印的方法，效果就是，彩色打印机打印出来的效果是彩色，而黑白打印机打印出来的效果是黑白的。
父类引用指向子类对象，例如：Parent p = new Child() ；对应到打印机的案例，new 一个对象的时候，父类打印机的引用会指向具体的对象，彩色打印机或者黑白打印机。
- 好处：便于接口的维护和拓展，可以将某一个子类切换成其他的子类，代码不需要做任何的改变，具有可替换性。
- 弊端：只有是子类重写的父类的方法，父类才可以调用，但如果子类的方法不是重写父类的，而是子类独有的，那么这个时候多态就使用不了，这个是需要注意的点。
Java的访问修饰符有哪些？
- private，私有的，被private修饰的类、方法、属性、只能被本类的对象所访问。
我什么都不跟别人分享。只有自己知道。
- default，默认的，在这种模式下，只能在同一个包内访问。
我的东西可以和跟我一块住的那个人分享。
- protected，受保护的，被protected修饰的类、方法、属性、只能被本类、本包、不同包的子类所访问。
我的东西我可以和跟我一块住的那个人分享。另外也可以跟不在家的儿子分享消息，打电话
- public，公共的，被public修饰的类、方法、属性、该类或非该类均可访问,可以跨类和跨包访问。
我的东西大家任何人都可以分享。
- 访问修饰符作用范围由大到小排列：
public>protected>default>private
重载(overload)和重写(override)的区别？
方法重写（Override）
1.方法重写是发生在父子类之间的关系（属于继承关系）。
2.子类方法重写父类方法，返回值类型、方法名和参数列表都要一模一样。
3.子类方法重写父类方法，必须要保证子类访问权限大于或等于父类访问权限。
访问权限从大到小: public > protected > default(默认) > private
4.使用@Override注解，检验是否重写成功，重写注解校验！
使用@Override注解作用：1.可以提高代码的可读性；2.可以防止重写出错！
方法重载（Overload）
方法重载概述:在同一个类中,出现多个同名的方法,但参数列表不同 （参数类型不同、个数不同、顺序不同）,与其他无关（与返回值无关）
方法重写（Override）和/方法重载（Overload）的区别
- 方法重载(Overload)是编译时的多态性，而方法重写(Override)是运行时的多态性。
- 构造器（constructor）不能被继承，因此不能被重写，但可以被重载。
- 重载：发生在同一个类中，方法名相同参数列表不同（参数类型不同、个数不同、顺序不同），与方法返回值和访问修饰符无关，即重载的方法不能根据返回类型进行区分
- 重写：发生在父子类中，方法名、参数列表必须相同，抛出的异常小于等于父类，访问修饰符大于或等于父类（里氏代换原则）；如果父类方法访问修饰符为private则子类中就不是重写。
接口和抽象类的区别是什么？
抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。
抽象类(abstract)：
- 概述：把一个不是具体的功能称为抽象的功能，而一个类中如果有抽象的功能，该类必须是抽象类
- 特点：
- 抽象类和抽象方法必须用abstract关键字修饰
- 抽象类中不一定有抽象方法，但是有抽象方法的类必须定义为抽象类
- 抽象类不能实例化
因为他不是具体的
抽象类有构造方法，但是不能实例化？构造方法的作用是什么？—>用于子类访问父类
抽象类的实例化其实是靠具体的子类实现的。是多态的方式 Animal a = new Cat();
- 数据的初始化
- 抽象的子类
如果不想写抽象方法，该子类是一个抽象类
重写所有的抽象方法，该子类是一个具体的类
- 抽象类成员的特点：
- 成员变量：既可以是变量，也可以是常量
- 构造方法：有，用于子类访问父类数据的初始化
- 成员方法：既可以是抽象的，也可以是非抽象的
- 特性：
- 抽象方法 强制要求子类做的事情
- 非抽象方法 子类继承的事情，提高代码的复用性
abstract不能与 private final static 关键字共存
private不能被继承，abstract要求用继承
final最终不能读写，abstract要求用几次
static方法可以通过类名去调用，abstract定义的方法没有方法体无意义
接口(interface)：
- 特点：
- 接口用关键字interface表示 —> interface 接口名 {}
- 类实现接口用implements表示
- 接口不能实例化。那么，接口如何实例化呢? —> 按照多态的方式来实例化。
- 接口的子类
可以是抽象类。但是意义不大。
可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
A:具体类多态(几乎没有)
B:抽象类多态(常用)
C:接口多态(最常用)
- 接口成员特点：
- 成员变量；只能是常量，并且是静态的。默认修饰符：public static final
- 构造方法：接口没有构造方法。
- 成员方法：只能是抽象方法。
- 默认修饰符：public abstract
类与类：继承关系,只能单继承,可以多层继承。
类与接口：实现关系,可以单实现,也可以多实现。并且还可以在继承一个类的同时实现多个接口。
接口与接口：继承关系,可以单继承,也可以多继承。
代码讲解
package 面向对象;
/**
* 抽象类和接口的区别：
* A:成员区别
* 抽象类：
* 成员变量：可以变量，也可以常量
* 构造方法：有
* 成员方法：可以抽象，也可以非抽象
* 接口：
* 成员变量：只可以常量
* 无构造方法
* 成员方法：只可以抽象
*
* B:关系区别
* 类与类
* 继承，单继承
* 类与接口
* 实现，单实现，多实现
* 接口与接口
* 继承，单继承，多继承
*
* C:设计理念区别
* 抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
* 接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。
*/
/*
教练和运动员案例
乒乓球运动员和篮球运动员。
乒乓球教练和篮球教练。
为了出国交流，跟乒乓球相关的人员都需要学习英语。
请用所学知识：
分析，这个案例中有哪些抽象类，哪些接口，哪些具体类。
整个分析过程，我是通过画图讲解的。
*/
//定义一个说英语的接口
/**
* 接口的特点：
* A:接口用关键字interface表示
* interface 接口名 {}
* B:类实现接口用implements表示
* class 类名 implements 接口名 {}
* C:接口不能实例化
* 那么，接口如何实例化呢? 按照多态的方式来实例化。
* D:接口的子类
* a:可以是抽象类。但是意义不大。
* b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
*
*/
interface SpeakEnglish {
/**
* 接口成员特点
* 成员变量；只能是常量，并且是静态的。
* 默认修饰符：public static final
* 建议：自己手动给出。
* 构造方法：接口没有构造方法。
* 成员方法：只能是抽象方法。
* 默认修饰符：public abstract
* 建议：自己手动给出。
*/
//说英语
public abstract void speak(); //默认abstract。只能是抽象方法。默认修饰符：public abstract
}
/**
* 抽象类的概述：
* 动物不应该定义为具体的东西，而且动物中的吃，睡等也不应该是具体的。
* 我们把一个不是具体的功能称为抽象的功能，而一个类中如果有抽象的功能，该类必须是抽象类。
*
* 抽象类的特点：
* A:抽象类和抽象方法必须用abstract关键字修饰
* B:抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类
* C:抽象类不能实例化
* 因为它不是具体的。
* 抽象类有构造方法，但是不能实例化?构造方法的作用是什么呢?
* 用于子类访问父类数据的初始化
* D:抽象的子类
* a:如果不想重写抽象方法，该子类是一个抽象类。
* b:重写所有的抽象方法，这个时候子类是一个具体的类。
*
* 抽象类的实例化其实是靠具体的子类实现的。是多态的方式。
* Animal a = new Cat();
*/
//定义人的抽象类
abstract class Person {
/**
* 抽象类的成员特点：
* 成员变量：既可以是变量，也可以是常量。
* 构造方法：有。
* 用于子类访问父类数据的初始化。
* 成员方法：既可以是抽象的，也可以是非抽象的。
*
* 抽象类的成员方法特性：
* A:抽象方法 强制要求子类做的事情。
* B:非抽象方法 子类继承的事情，提高代码复用性。
*/
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 void sleep() {
System.out.println("人都是要睡觉的");
}
//吃饭，运动员和教练吃的不一样。这里使用抽象方法
public abstract void eat();
}
//定义运动员抽象类
abstract class Player extends Person {
public Player() {}
public Player(String name,int age) {
super(name,age);
}
//学习，乒乓器和篮球运动员学习的东西不一样。这里使用抽象方法
public abstract void study();
}
//定义教练抽象类
abstract class Coach extends Person {
public Coach() {}
public Coach(String name,int age) {
super(name,age);
}
//教，乒乓器和篮球运动员教的东西不一样。这里使用抽象方法
public abstract void teach();
}
//定义乒乓球运动员具体类
class PingPangPlayer extends Player implements SpeakEnglish {
public PingPangPlayer(){}
public PingPangPlayer(String name,int age) {
super(name,age);
}
//吃
public void eat() {
System.out.println("乒乓球运动员吃大白菜，喝小米粥");
}
//学习
public void study() {
System.out.println("乒乓球运动员学习如何发球和接球");
}
//说英语
public void speak() {
System.out.println("乒乓球运动员说英语");
}
}
//定义篮球运动员具体类
class BasketballPlayer extends Player {
public BasketballPlayer(){}
public BasketballPlayer(String name,int age) {
super(name,age);
}
//吃
public void eat() {
System.out.println("篮球运动员吃牛肉，喝牛奶");
}
//学习
public void study() {
System.out.println("篮球运动员学习如何运球和投篮");
}
}
//定义乒乓球教练具体类
class PingPangCoach extends Coach implements SpeakEnglish {
public PingPangCoach(){}
public PingPangCoach(String name,int age) {
super(name,age);
}
//吃
public void eat() {
System.out.println("乒乓球教练吃小白菜，喝大米粥");
}
//教
public void teach() {
System.out.println("乒乓球教练教如何发球和接球");
}
//说英语
public void speak() {
System.out.println("乒乓球教练说英语");
}
}
//定义篮球教练具体类
class BasketballCoach extends Coach {
public BasketballCoach(){}
public BasketballCoach(String name,int age) {
super(name,age);
}
//吃
public void eat() {
System.out.println("篮球教练吃羊肉，喝羊奶");
}
//教
public void teach() {
System.out.println("篮球教练教如何运球和投篮");
}
}
class InterfaceDemo {
public static void main(String[] args) {
//测试运动员(乒乓球运动员和篮球运动员)
//乒乓球运动员
PingPangPlayer ppp = new PingPangPlayer();
ppp.setName("王浩");
ppp.setAge(33);
System.out.println(ppp.getName()+"---"+ppp.getAge());
ppp.eat();
ppp.sleep();
ppp.study();
ppp.speak();
System.out.println("----------------");
//通过带参构造给数据
ppp = new PingPangPlayer("刘洋",36);
System.out.println(ppp.getName()+"---"+ppp.getAge());
ppp.eat();
ppp.sleep();
ppp.study();
ppp.speak();
System.out.println("----------------");
//篮球运动员
BasketballPlayer bp = new BasketballPlayer();
bp.setName("姚明");
bp.setAge(34);
System.out.println(bp.getName()+"---"+bp.getAge());
bp.eat();
bp.sleep();
bp.study();
//bp.speak(); //没有该方法
}
}
573
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
