Java的面向对象

面向对象

补充：对象数组 用来存储对象

封装：

封装在Java当中的体现：

1.方法就是一种封装

2.关键字 private 也是一种封装 （封装是为了保护隐私）

​ 用 private 关键字将需要保护的成员变量进行修饰

private int age;

​ 一旦使用 private 修饰后 只能在本类中调用

​ 此时若想实现其他类调用 需要如下操作

​ 在含有 private 修饰的类中

/*向 age 传入数据*/
public void setAge(int num){
  	age = num;   
}

/*获取 age 数据*/
public int getAge(){
    return age;
}

​ 必须叫 setXxx getXxx

​ 注意事项：对于基本类型当中的boolean值，Getter 方法一定要写成 isXxx 的形式

3.this 关键字

this.name  /* 当参数变量和成员变量名相同时 优先使用参数变量 
		     这时需要 用this. 来表示成员变                量*/

4.构造方法

​ 构造方法是专门用来创建对象的方法，当我们通过关键字 new 来创建对象时，其实就是在调用 构造方法

​ 格式：

public 类名称( 参数类型 ){
    方法体
}

注意事项：

1.构造方法的名称必须和这个类名一模一样，大小写也完全一样

2.构造方法不要写返回值类型，连 void 都不用写

3.构造方法不能 return 一个具体的返回值

4.如果没有编写任何构造方法，那么编译器将会默认一个无参空的构造方法

5.一旦编写了至少一个构造方法，编译器将不会默认构造方法

5.匿名对象：

匿名对象就是只有右边的对象，没有左边的名字和赋值运算符

public class Demo{
	public static void main(String[] args){
		new Worker().name;  /* 给另一个含有name成员变量的类赋值 */  
	}
}

注意事项：

匿名对象只能使用唯一的一次

使用建议：如果确定有一个对象只需要使用唯一的一次，就可以使用匿名对象

继承：

继承是多态的前提，如果没有继承，就没有多态。

继承（分为父类和子类 子类中有父类的成员变量和成员方法）

继承的格式：

在继承的关系中，“子类可以被当作父类看待” 例如：父类是员工，子类是讲师，那么讲师也是一个员工

定义父类的格式：（就是一个普通的类定义）

public class 父类名称{
    
}

public class 子类名称 extends 父类名称{
    
}

继承中成员变量的访问特点

在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式。

1.直接通过子类对象访问成员变量；

​ 等号左边是谁，就优先用谁，没有则向上找。

2.间接通过成员方法访问成员变量；

​ 要看该方法属于谁，就优先用谁，没有就向上找。

3.区分子类方法中重名的三种变量；

​ 局部变量：直接写成员变量名

​ 本类的成员变量： this.成员变量名

​ 父类的成员变量： super.成员变量名 （super 关键字）

4.继承中成员方法的访问特点；

​ 创建的对象是谁，就优先用谁，如果没有则向上找。

注意事项：无论是成员方法还是成员变量，如果没有 都是向上找父类，绝对不会向下找子类。

5.继承中方法的覆盖重写

​ 在继承关系当中，方法的名称一样，参数列表也一样。

​ 而方法的重载，参数列表不一样

注意事项：

​ 1.必须保证父子类之间方法的名称相同，参数列表也相同。

​ @override: 写在方法前面，用来检测是不是有效的正确重写。

​ 2.子类方法的返回值必须【小于等于】父类方法的返回值范围。

前提：Java.lang.Object 类是所有类的公共最高父类 （祖宗类），Java.lang.String 就是 Object 的子类

​ 3.子类方法的权限必须【大于等于】父类方法的权限修饰符

小扩展提示： public > protected > （default） > private

备注，default 为留空 不是一个关键字

6.继承关系中，父子类构造方法的访问特点

​ （1）子类构造方法当中有一个默认隐含的 “super” 调用，所以一定是先执行父类构造方法 再执行子类构造方法

​ （2）可以通过 super 关键字来子类构造调用父类重载构造

​ （3）super 的父类构造调用，必须是子类构造方法的第一个语句 不能一个子类构造方 法调用多次 super 构造，super 只能有一个 还必须是第一个

7. super 关键字的三种用法

   （1）在子类的成员方法中，访问父类的成员变量

   （2）在子类的成员方法中，访问父类的成员方法

   （3）在子类的构造方法中，访问父类的构造方法

8. this 关键字用来访问父类内容，而 this 关键字用来访问本类内容。三种用法：

   （1）在本类的成员方法中，访问本类的成员变量

   （2）在本类的成员方法中，访问本类的另一个成员方法

   （3）在本类的构造方法中，访问本类的另一个构造方法

9. java 语言 继承的三个特征：

   （1）Java 语言是单继承的，一个类的直接父类只能有唯一的一个

   （2）Java 语言可以多继承

   （3）Java 语言 一个子类只可以有一个父类 一个父类可以有很多子类

抽象：

如果父类当中的方法不确定如何进行 { } 方法体实现，那么这就应该是一个 抽象方法

一、抽象方法：

就是加上 abstract 关键字，然后去掉大括号，直接分号结束

二、抽象类：

抽象方法所在的类，必须是抽象类才行 在 class 之前写上 abstract 即可

三、如何使用抽象类和抽象方法：

1.不能直接创建 new 抽象类对象

2.必须用一个子类来继承抽象父类

3.子类必须覆盖重写抽象父类当中所有的抽象方法 覆盖重写（实现）：去掉抽象方法的 abstract 关键字，然后补上方法体大括号

4.创建子类对象进行使用

四、注意事项：

1.抽象类不能直接创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象

2.抽象类中，可以有构造方方法，是供子类创建对象时，初始化父类成员用的。

3.抽象类中，不一定包含抽象方法，但是有抽象方法的类一定是抽象类。

4.抽象类的子类，必须重写抽象父类中所有的抽象方法。

public class DemoMain {
	public static void main(String[] args) {
	/*	Animal animal = new Animal();   错误写法 不能直接new对象*/
		
		Cat cat = new Cat();
		cat.eat();
	}
}


public abstract class Animal {
	//这是一个抽象方法
	public abstract void eat();
}


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

接口：

接口就是多个类的公共规范 接口是一种引用数据类型，最重要的内容就是其中的：抽象方法

如何定义一个接口

public interface 接口名称{
    // 接口内容
}

​ 备注：接口编译生成的字节码文件仍然为 .class

接口中可以包含的内容有：

1. 常量
2. 抽象方法
3. 默认方法 （ Java 8 之后可以）
4. 静态方法
5. 私有方法 （ Java 9 之后可以）

（1）接口中定义抽象方法

接口当中的抽象方法，修饰符必须是两个固定的关键字： public abstract

可省略 但不推荐

public interface MyInterfaceAbstract {
	public abstract void methodAbs(); //这是一个抽象方法
}

接口使用步骤：

1.接口不能直接使用，必须有一个 实现类 来 实现 该接口

//格式：
public class 实现类名称 implements 接口名称{
    
}

// 接口当中默认方法   可以解决接口升级问题
public class 实现类名称 implements 接口名称{
    public default void methodDefault(){
        System.out.println("这是新添加的默认方法");
    }
}

//对默认方法的使用
public class Demo{
    public static void main(String[] args){
        实现类名称 a = new 实现类名称();
        a.methodDefault;   //实现类会继承这个默认方法 
    }
}

//接口的静态方法
public static 返回值类型 方法名称(参数列表){
    
}
//接口静态方法的使用
public class Demo{
    public static void main(String[] args){
        //直接接口名调用
    }
}


//接口私有方法
private 返回类型 方法名称1(参数列表){
    方法体
}
private static 返回类型 方法名称2(参数列表){
    方法体
}
//接口私有方法的使用
public class Demo{
    public void method(){
        私有方法名称1();   //错误用法  仅能接口内部方法调用私有方法1
    }
}

2.接口的实现类必须覆盖重写接口中的所有抽象方法 即重写

3.创建实现类的对象，进行使用。

注意事项：

如果实现类并没有覆盖重写接口中的所有的抽象方法，那么这个实现类自己就必须是抽象类

4.接口当中也可以定义"成员变量" 但是必须使用 public static final 三个关键字进行修饰

public static final int num = 10;		//常量， 一旦赋值 不可更改
									//接口中的常量必须赋值

小结：

1.接口不能有静态代码块 不能有构造方法

2.一个类的直接父类是唯一的，但是一个类可以同时实现多个接口

多态：

extends 继承 或者 implements 实现 是多态性的前提。

一个对象拥有多种形态，这就是 对象的多态性

代码当中体现多态性，其实就是一句话：父类引用指向子类对象

格式：

父类名称 对象名 = new 子类名称 ( );

或者：

接口名称 对象名 = new 实现类名称 ( );

多态的好处：

(该图来自哔哩哔哩Java基础视频)