Java—面向对象
1.面向对象
面向过程：当需要实现一个功能时，每个具体的步骤都要亲力亲为，详细处理每个细节。（强调过程）
面向对象：当需要实现一个功能时，不关心具体的步骤，而是找一个已经具有该功能的的人或物体，通过该人或物体来实现这个功能。（强调对象）
面向对象编程(Object Oriented Programing，OOP)的本质：以类的方式组织代码，以对象的组织（封装）数据。
面向对象的三大基本特征：封装、继承和多态。
类：是一组相关属性和行为的集合，可以看成是一类事务的模板，使用事物的属性特征和行为特征来描述该类事物。
- 属性：就是该事物的状态信息。
- 行为：就是该事物能够做什么。
对象：是一类事物的具体体现，对象是类的一个实例，必然具备该类事物的属性和行为。
类与对象的关系
- 类是对一类事物的描述，是抽象的。
- 对象是一类事物的实例，是具体的。
- 类是对象的模板，对象是类的实体。
1.1 对象的使用
创建对象：
类名 对象名 = new 类名（）；
使用对象访问类中的成员：
对象名.成员变量;
对象名.成员方法();
对象的使用格式举例：
对应到Java的类当中：
成员变量（属性）：
String name; // 姓名
int age; // 年龄
成员方法（行为）：
public void eat() {} // 吃饭
public void sleep() {} // 睡觉
public void study() {} // 学习
注意事项：
1. 成员变量是直接定义在类当中的，在方法外边。
2. 成员方法不要写static关键字。
*/
public class Student {
// 成员变量
String name; // 姓名
int age; // 姓名
// 成员方法
public void eat() {
System.out.println("吃饭饭！");
}
public void sleep() {
System.out.println("睡觉觉！");
}
public void study() {
System.out.println("学习！");
}
}
1.2 成员变量和局部变量
变量根据定位位置的不同，有不同的名字。
（1）在类中的位置不同
成员变量：类中，方法外
局部变量：方法中或者方法声明上（形式参数）
（2）作用范围不一样
成员变量：类中
局部变量：方法中
（3）初始值不同
成员变量：有默认值
局部变量：没有默认值，必须定义，赋值，最后使用
（4）在内存中的位置不同
成员变量：堆内存
局部变量：栈内存
（5）生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
2.封装
封装：禁止直接访问一个对象中的数据，应通过操作接口来访问。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。
1.方法就是一种封装
2.关键字private也是一种封装
2.1 private的使用格式
private 数据类型 变量名；
1.使用private修饰成员变量
2.提供getXxx方法/setXxx方法/isXxx方法,可以访问成员变量，代码如下：
/*
问题描述：定义Person的年龄时，无法阻止不合理的数值被设置进来。
解决方案：用private关键字将需要保护的成员变量进行修饰。
一旦使用了private进行修饰，那么本类当中仍然可以随意访问。
但是！超出了本类范围之外就不能再直接访问了。
间接访问private成员变量，就是定义一对儿Getter/Setter方法
必须叫setXxx或者是getXxx命名规则。
对于Getter来说，不能有参数，返回值类型和成员变量对应；
对于Setter来说，不能有返回值，参数类型和成员变量对应。
对于基本类型当中的boolean值，Getter方法一定要写成isXxx的形式，而setXxx规则不变。
*/
public class Person {
private String name; // 姓名
private int age; // 年龄
private boolean male; // 是不是爷们儿
public void setMale(boolean b) {
male = b;
}
public boolean isMale() {
return male;
}
public void show() {
System.out.println("我叫：" + name + "，年龄：" + age);
}
// 这个成员方法，专门用于向age设置数据
public void setAge(int num) {
if (num < 100 && num >= 9) { // 如果是合理情况
age = num;
} else {
System.out.println("数据不合理！");
}
}
// 这个成员方法，专门私语获取age的数据
public int getAge() {
return age;
}
}
2.2 封装优化-----this 关键字
this.成员变量名;
使用this修饰方法中的变量，解决成员变量被隐藏的问题，代码如下：
/*
当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量。
如果需要访问本类当中的成员变量，需要使用格式：
this.成员变量名
“通过谁调用的方法，谁就是this。”
*/
public class Student{
private String name;
private int age;
public void setName(String name){
this.name = name;
}
public String getName(){
return this.name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return this.age;
}
2.3 封装优化------构造方法
当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。
（无论是否自定义构造方法，所有类都有构造方法，因为Java自动提供了一个无参数构造方法，一旦自己定义了构造方法，Java自动提供的默认无参数构造方法就会失效。）
构造方法的定义格式
修饰符 构造方法名(参数列表){
//方法体
}
构造方法的写法上，方法名与它所在的类名相同。它没有返回值，所有不需要返回值类型，甚至不需要void，使用构造方法后，代码如下：
/*
构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。
格式：
public 类名称(参数类型 参数名称) {
方法体
}
注意事项：
1. 构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
2. 构造方法不要写返回值类型，连void都不写
3. 构造方法不能return一个具体的返回值
4. 如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做。
public Student() {}
5. 一旦编写了至少一个构造方法，那么编译器将不再赠送。
6. 构造方法也是可以进行重载的。
重载：方法名称相同，参数列表不同。
*/
public class Student {
// 成员变量
private String name;
private int age;
// 无参数的构造方法
public Student() {
System.out.println("无参构造方法执行啦！");
}
// 全参数的构造方法
public Student(String name, int age) {
System.out.println("全参构造方法执行啦！");
this.name = name;
this.age = age;
}
// Getter Setter
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;
}
}
注意：
1.如果你不提供构造方法，系统就会给出无参数构造方法
2.如果你提供了构造方法，系统将不再提供无参数构造方法
3.构造方法是可以重载的，即可以定义参数，也可以不定义参数
2.4 标准代码--------JavaBean
JavaBean是Java语言编写类的一种标准规范，符合JavaBean的类，要求类必须是具体的和公共的，并且具有无参数的构造方法，提供用来操作成员变量的set和get方法。
/*
一个标准的类通常要拥有下面四个组成部分：
1. 所有的成员变量都要使用private关键字修饰
2. 为每一个成员变量编写一对儿Getter/Setter方法
3. 编写一个无参数的构造方法
4. 编写一个全参数的构造方法
这样标准的类也叫做Java Bean
*/
public class Student {
private String name; // 姓名
private int age; // 年龄
public Student() {
}
public Student(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;
}
}
3.继承
定义：多个类中存在相同属性和行为时，将这些共同的属性和行为抽象为一个父类，其他的子类就可以继承父类的属性和行为，使得子类对象具有与父类相同的属性、和行为。
继承的优点：
- 提高代码的复用性
- 类与类之间产生了关系，是多态的前提
3.1 继承的格式
通过extends关键字，可以声明一个子类继承一个父类，定义格式如下：
public class 父类名称{//定义父类的格式
..........
}
public class 子类名称 extends 父类名称{
...........//定义子类格式
}
3.2 成员变量重名
在父子类的继承关系中，如果成员变量重名，则创建子类对象时，访问有两种方式。
1.直接通过子类对象访问成员变量：
等号左边是谁，就优先用谁，没有则向上找。
2.间接通过成员方法访问成员变量：
该方法属于谁，就优先用谁，没有则向上找
public class Demo02ExtendsField {
public static void main(String[] args) {
Father father = new Father();//创建父类对象
System.out.println(father.numFather);
System.out.println("====================");
Son son = new Son();
System.out.println(son.numFather);//10
System.out.println(son.numSon);
System.out.println("====================");
System.out.println(son.num );//优先子类200
System.out.println("===================");
son.methodSon();//这个方法定义在子类，优先用子类，没有再向上找
son.methodFather(); //这个方法在父类中定义的
}
}
public class Father {
int numFather = 10;
int num = 100;
public void methodFather(){
System.out.println(num);
}
}
public class Son extends Father{
int numSon = 20;
int num = 200;
public void methodSon(){
System.out.println(num);
}
}
子类和父类中出现同名的成员变量时，也可以使用super关键字来访问父类中的同名变量。可以用this关键字来访问本类的同名变量。
3.3 成员方法重名——重写(Override)
如果子类和父类中出现重名的成员方法，这时的访问是一种特殊的情况，叫做方法重名(Override)。
方法重写：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。
在父子类的继承关系中，创建子类对象，访问成员方法规则;
创建的对象是谁，就优先用谁，如果没有则向上找
注意事项：
无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。
重写(Override)：方法的名称一样，参数列表也一样。覆盖、覆写。
重载(Overload)：方法的名称一样，参数列表不一样。
方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。
public class Demo04ExtendsMethod {
public static void main(String[] args) {
Son son = new Son();
son.methodFather();
son.methodSon();
System.out.println("===========");
son.method();
}
}
public class Father {
public void methodFather(){
System.out.println("父类方法执行！");
}
public void method(){
System.out.println("父类方法重名执行！");
}
}
public class Son extends Father {
public void methodSon(){
System.out.println("子类方法执行！");
}
@Override
public void method(){
System.out.println("子类方法重名执行！");
}
}
方法覆盖重写的注意事项：
1.必须保证父子类之间方法的名称相同，参数列表也相同。
@Override： 写在方法前面，用来检测是不是有效的的正确覆盖重写。
这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。
2.子类方法的返回值必须小于父类方法的返回值范围。
Object类是所有类的公共最高父类（祖宗类），java.long.String就是Object的子类。
3.子类方法的权限必须大于等于父类方法的权限修饰符
小扩展提示：public > protected > (default) > private
备注：(default)不是关键字default，而是什么都不写，留空。
3.4 继承中的构造方法
继承关系中，父类和子类构造方法的访问特点
1.子类构造方法当中有有一个默认隐含的“super()”调用，所以一定是先调用的父类构造，后执行的子类构造
2.子类构造可以通过super关键字来调用父类重载构造
3.super的父类构造方法必须是子类构造方法的第一个语句，不能一个子类构造调用多次super构造
总结：
子类必须调用父类构造方法，不写则赠送super()；写了则用指定的super调用，super只能有一个，还必须是第一个
public class Demo07Constructor {
public static void main(String[] args) {
Son son = new Son();
System.out.println("==========");
Father father = new Father();
}
}
public class Father {
public Father(){
System.out.println("1-父类构造方法!");
}
public Father(int num){
System.out.println("2-父类构造方法!");
}
}
public class Son extends Father {
public Son(){
super(); //调用父类无参构造
// super(5);//在调用父类重载构造方法
System.out.println("子类构造方法!");
}
}
3.5 super和this
super关键字的用法有三种：
1.在子类的成员方法中，访问父类的成员变量。
2.在子类的成员方法中， 访问父类的成员方法。
3.在子类的构造方法中，访问父类的构造方法。
super关键字用来访问父类内容，而this用来访问本类内容，用法有三种
1.在本类的成员方法中，访问本类的成员变量。
2.在本类的成员方法中，访问本类的另一个成员方法。
3.在本类的构造方法中，访问本类的的另一个构造方法。
在第三种用法当中注意：
A.this(…)调用必须是构造方法的第一个语句,唯一一个。
B.super和this两种构造调用，不能同时使用。
3.6 继承的特点
1.java只支持单继承，不支持多继承
一个类的直接父类只能有唯一一个
2.java语言可以多级继承
我有一个父亲，我父亲还有一个父亲，也就是爷爷。
3.子类和父类是一种相对概念
一个子类的直接父类是唯一的，但是一个父类可以拥有很多个子类。可以有很多个兄弟姐妹，生二胎。
3.7抽象类
抽象类就是将父类进一步抽象出来的类。父类中的方法被它们的子类重写，子类各自的实现都不尽相同，那么父类的方法声明和方法主体只有声明还有意义，方法主体没有存在的意义的意义，把没有方法主体的方法称为抽象方法。包含抽象方法的类就是抽象类。
抽象方法：没有方法体的方法
抽象类：包含抽象类的类
如何使用抽象类和抽象方法：
1.不能直接创建抽象类对象。
2.必须用一个子类继承抽象父类。
3。子类覆盖重写抽象父类当中所有的抽象方法。
覆盖重写（实现），子类去掉抽象方法的关键字abstract，然后补上方法体大括号。
4.创建子类对象进行使用。
抽象方法定义格式
修饰符 abstract 返回值类型 方法名（参数列表）
抽象类定义格式
public abstract class 类名字{
}
抽象的使用
继承抽象类的子类必须重写父类所有的抽象方法，否则，该子类也必须声明为抽象类。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。
public abstract class Animal {
//这是一个抽象方法，代表吃东西，但是具体吃什么(大括号的内容)不确定。
public abstract void eat();
//这是普通的成员方法
public void normalMethod(){
}
}
public class Cat extends Animal {
@Override
public void eat(){
System.out.println("猫吃鱼!");
}
}
public class DemoMain {
public static void main(String[] args) {
Cat cat = new Cat();
cat.eat();
}
}
4.多态
4.1 接口
接口就是多个类的公共规范。接口是一种引用数据类型，最重要的内容就是其中的：抽象方法。
如何定义一个接口的格式：
public interface 接口名称 {
// 抽象方法
//默认方法
//静态方法
//私有方法
}
4.1.1 抽象方法的使用
/*
在任何版本的Java中，接口都能定义抽象方法。
格式：
public abstract 返回值类型 方法名称(参数列表);
注意事项：
1. 接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
2. 这两个关键字修饰符，可以选择性地省略。
3. 方法的三要素，可以随意定义。
*/
public interface MyInterfaceAbstract {
// 这是一个抽象方法
public abstract void methodAbs1();
// 这也是抽象方法
abstract void methodAbs2();
// 这也是抽象方法
public void methodAbs3();
// 这也是抽象方法
void methodAbs4();
}
4.1.2 默认方法的使用
可以继承可以重写，只能二选一，但是只能通过实现类的对象来调用
/*
从Java 8开始，接口里允许定义默认方法。
格式：
public default 返回值类型 方法名称(参数列表) {
方法体
}
备注：接口当中的默认方法，可以解决接口升级的问题。
*/
public interface MyInterfaceDefault {
// 抽象方法
public abstract void methodAbs();
// 新添加的方法，改成默认方法
public default void methodDefault() {
System.out.println("这是新添加的默认方法");
}
}
4.1.3 静态方法的使用
静态方法与.class文件相关，只能直接使用接口名调用，不可以通过实现类的类名或实现类的对象调用。
/*
从Java 8开始，接口当中允许定义静态方法。
格式：
public static 返回值类型 方法名称(参数列表) {
方法体
}
提示：就是将abstract或者default换成static即可，带上方法体。
*/
public interface MyInterfaceStatic {
public static void methodStatic() {
System.out.println("这是接口的静态方法！");
}
}
public class MyInterfaceStaticImpl implements MyInterfaceStatic {
}
/*
注意事项：不能通过接口实现类的对象来调用接口当中的静态方法。
正确用法：通过接口名称，直接调用其中的静态方法。
格式：
接口名称.静态方法名(参数);
*/
public class Demo03Interface {
public static void main(String[] args) {
// 创建了实现类对象
MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();
// 错误写法！
// impl.methodStatic();
// 直接通过接口名称调用静态方法
MyInterfaceStatic.methodStatic();
}
}
4.1.4 私有方法的使用
私有方法：只有默认方法调用
私有静态方法：默认方法和静态方法调用
如果一个接口中有多个默认方法，并且方法中有重复的内容，封装到私有方法中，供默认方法去调用。
/*
问题描述：
我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题。
但是这个共有方法不应该让实现类使用，应该是私有化的。
解决方案：
从Java 9开始，接口当中允许定义私有方法。
1. 普通私有方法，解决多个默认方法之间重复代码问题
格式：
private 返回值类型 方法名称(参数列表) {
方法体
}
2. 静态私有方法，解决多个静态方法之间重复代码问题
格式：
private static 返回值类型 方法名称(参数列表) {
方法体
}
*/
public interface MyInterfacePrivateA {
public default void methodDefault1() {
System.out.println("默认方法1");
methodCommon();
}
public default void methodDefault2() {
System.out.println("默认方法2");
methodCommon();
}
private void methodCommon() {
System.out.println("AAA");
System.out.println("BBB");
System.out.println("CCC");
}
}
4.1.5 接口常量
/*
接口当中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰。
从效果上看，这其实就是接口的【常量】。
格式：
public static final 数据类型 常量名称 = 数据值;
备注：
一旦使用final关键字进行修饰，说明不可改变。
注意事项：
1. 接口当中的常量，可以省略public static final，注意：不写也照样是这样。
2. 接口当中的常量，必须进行赋值；不能不赋值。
3. 接口中常量的名称，使用完全大写的字母，用下划线进行分隔。（推荐命名规则）
*/
public interface MyInterfaceConst {
// 这其实就是一个常量，一旦赋值，不可以修改
public static final int NUM_OF_MY_CLASS = 12;
}
4.1.6 接口的多实现
在继承体系中，一个类只能继承一个父类，对于接口而言，一个类可以实现多个接口，这就叫做接口的多实现，并且，一个类能继承一个父类，同时实现多个接口。
public class MyInterfaceImpl /*extends Object*/ implements MyInterfaceA, MyInterfaceB {
@Override
public void methodA() {
System.out.println("覆盖重写了A方法");
}
@Override
public void methodB() {
System.out.println("覆盖重写了B方法");
}
@Override
public void methodAbs() {
System.out.println("覆盖重写了AB接口都有的抽象方法");
}
@Override
public void methodDefault() {
System.out.println("对多个接口当中冲突的默认方法进行了覆盖重写");
}
}
4.1.7 接口的多继承
一个接口能继承另一个或者多个接口，这和类之间继承比较相似。接口的继承使用extends ，子接口继承父接口的方法，如果父接口中的默认方法有重名的，那么子接口需要重写一次。
package Demo02;
/*
使用接口的时候，需要注意：
1. 接口是没有静态代码块或者构造方法的。
2. 一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。
格式：
public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB {
// 覆盖重写所有抽象方法
}
3. 如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
4. 如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
5. 如果实现类锁实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
6. 一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。
*/
public class Demo01 {
public static void main(String[] args) {
Son son = new Son();
son.methodA();
son.method();
System.out.println("==========");
son.methodAbs();
son.methodDefault();
}
}
- 类与类之间是单继承的。直接父类只有一个。
- 类与接口之间是多实现的。一个类可以实现多个接口。
- 接口与接口之间是多继承的。
注意事项：
- 多个父接口当中的抽象方法如果重复，没关系。
- 多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，【而且带着default关键字】。
4.2.多态
多态：同一行为，具有多个不同表现形式。
代码当中体现多态性，其实就是一句话：父类引用指向子类对象。
格式：
父类名称 对象名 = new 子类名称();
接口名称 对象名 = new 实现类名称();
访问成员变量的两种方式：
-
直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找。
-
间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找。
package Demo05; public class Demo01Multi { public static void main(String[] args) { Father son = new Son(); System.out.println(son.num);//父类：10 System.out.println("=========="); son.showNum(); son.method(); System.out.println("=================="); son.methodFather(); // son.methodSon(); //错误写法 } } public class Father { int num = 10; public void showNum(){ System.out.println(num); } public void method(){ System.out.println("我是爸爸"); } public void methodFather(){ System.out.println("父类方法"); } } public class Son extends Father{ int num = 20; @Override public void showNum(){ System.out.println(num); } @Override public void method(){ System.out.println("我是爸爸的儿子"); } public void methodSon(){ System.out.println("子类方法"); } }
在多态的代码当中，成员方法的访问规则是：
看new的是谁，就优先用谁，没有则向上找。
口诀：编译看左边，运行看右边。
对比一下：
成员变量：编译看左边，运行还看左边。
成员方法：编译看左边，运行看右边。
4.3引用类型转换
4.3.1向上转型
多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的 。
当父类引用指向一个子类对象时，便是向上转型。
使用格式：
父类类型 变量名 = new 子类类型（）;
向上转型一定是安全的，没有问题的，正确的。但是也有一个弊端：
对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。
解决方案：用对象的向下转型【还原】。
父类类型向子类类型转换的过程，这个过程是强制的。
一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。
使用格式：
子类类型 变量名 = （子类类型）父类变量名：
如何才能知道一个父类引用的对象，本来是什么子类？为了避免出现ClassCastException报错，使用instanceof关键字，给引用变量做类型的校验。
格式：
对象 instanceof 类名称
这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例。
package Demo06;
public class Demo01Main {
public static void main(String[] args) {
Animal animal = new Cat();
animal.eat();
System.out.println("=========");
//向下转型，进行“还原”动作
Cat cat = (Cat)animal;
cat.catchMouse();
System.out.println("===========");
if(animal instanceof Cat){
Cat cat1 = (Cat)animal;
cat1.catchMouse();
}
else if(animal instanceof Dog){
Dog dog = (Dog) animal;
dog.watchHouse();
}
}
}
172
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
