Java面向对象

一、类与对象：

1、类和对象是什么？

类：是共同特征的描述（设计图）；

对象：是真实存在的案例

2、如何得到对象？

public class 类名 {
    1、成员变量
    2、成员方法
}

类名 对象名 = new 类名();

3、拿到对象后能做什么？

对象.成员变量；

对象.成员方法(...)

二、定义类的补充注意事项：

用来描述一类事物的类，专业叫做：Javabean类

在Javabean类中，是不写main方法的

在以前，编写main方法的类，叫做测试类

我们可以在测试类中创建Javabean类的对象并进行赋值调用

Javabean类：

类名首字母建议大写，需要见名知意，驼峰模式

一个Java文件中可以定义做个class类，且只能一个类是public修饰，

而且public修饰的类名必须成为代码文件名

实际开发中建议还是一个文件定义一个class类

成员变量的完整定义格式是：修饰符 数据类型 变量名称 = 初始化值；

一般无需指定初始值，存在默认值

三、封装：

1、如何正确设计对象的属性和方法？

原则：对象代表什么，就得封装对应的数据，并提供数据对应的行为

2、private关键字：

#是一个权限修饰符

#可以修饰成员（成员变量和成员方法）

#被private修饰的成员只能在本类中才能访问

public class GirlFriend {
    private int age;

    //set（赋值）
    public void setAge(int a) {
        if(a >= 18 && a <= 50) {
            age = a;
        } else {
            System.out.println("非法数据");
        }
    }

    //get（获取）
    public int getAge() {
        return age;
    }
}

// 针对于每一个私有化的成员变量，都要提供 get 和 set 方法

// set方法：给成员变量赋值

//get方法：对外提供成员变量的值

// 作用：给成员变量name进行赋值的
public void setName(String n) {
    name = n;
}

// 作用：对外提供name属性的
public String getName() {
    return name:
}

3、this 关键字：

public void setName(String name) {
    this.name = name;
}

就近原则：

System.out.println(age);

System.out.println(this.age);

this的作用？

可以区别成员变量和局部变量

this关键字的三种用法：

~ 在本类的成员方法中，访问本类的成员变量

~ 在本类的成员方法中，访问本类的另一个成员方法

~ 在本类的构造方法中，访问本类的另一个构造方法

4、构造方法：

### 创建对象的时候，虚拟机会自动调用构造方法，给成员变量进行初始化

5、标准的JavaBean类：

a. 类名需要见名知意

b. 成员变量使用private修饰

c. 提供至少两个构造方法

~ 无参构造方法

~ 带全部参数的构造方法

d. 成员方法

~ 提供每一个成员变量对应的setXxx() / getXxx()

~ 如果还有其他行为，也需要写上

四、继承 Inheritance：

在面向对象编程中，我们已经创建了一个类，现在又想创建一个与之相似的类，比如添加新方法或修改原来的方法，我们不必从头开始，我们可以从原来的类派生出新的类，我们将原来的类称为父类或者基类，派生出来的类叫做子类，子类则会继承父类的数据和方法。

// 定义父类的格式：（一个普通的类定义）
public class 父类名称 {
    // ...
}

// 定义子类的格式：
public class 子类名称 extends 父类名称 {
    // ... 
}

1、super关键字：

三种用法：

~ 在子类的成员方法中，访问父类的成员变量

~ 在子类的成员方法中，访问父类的成员方法

~ 在子类的成员方法中，访问父类的构造方法

Java继承的三个特点：

# Java语言是单继承的，一个类的直接父类只有唯一一个

# Java可以多级继承

# 一个子类的直接父类是唯一的，但是一个父类可以拥有很多个子类

五、抽象：

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

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

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

public abstract class Animal {
    
    // 这是一个抽象方法，代表吃东西，但是不知道具体吃什么
    public abstract void eat();
}

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

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

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

3、子类必须覆盖重写抽象父类中的所有抽象方法：

覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号

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

public class Cat extends Animal {

    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class DemoMain {

    public static void main(String[] args) {
        // Animal animal = new Animal();
        // 错误写法！不能直接创建抽象类对象
        
        Cat cat = new Cat();
        cat eat();

    }
}

六、接口：

接口就是多个类的公共规范

接口是一种引用数据类型，最重要的内容就是其中的抽象方法

如何定义一个接口的格式：

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

备注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java --> .class

如果是Java 7，那么接口中可以包含的内容有：

1、常量

2、抽象方法

如果是Java 8，还可以额外包含有：

3、默认方法

4、静态方法

如果是Java 9，还可以额外包含有：

5、私有方法

接口小结：

在Java 9+版本中，接口的内容可以有：

1、成员变量其实是常量，格式：

public static final 数据类型 常量名称 = 数据值

//注意：
//     常量必须进行赋值，而且一旦赋值不能改变
//     常量名称完全大写，用下划线进行分隔

2、接口中最重要的就是抽象方法，格式：

public abstract 返回值类型 方法名称（参数列表）;
// 注意：
//     实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类

3、从Java 8开始，接口里允许定义默认方法，格式：

public default 返回值类型 方法名称（参数列表） { 方法体 }
// 注意：
//     默认方法也可以被覆盖重写

4、从Java 8开始，接口里允许定义静态方法，格式：

public static 返回值类型 方法名称（参数列表） { 方法体 }
// 注意：
//     应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法

5、从Java 9开始，接口里允许定义私有方法，格式：

// 普通私有方法
private 返回值类型 方法名称（参数列表）{ 方法体 }

// 静态私有方法
private static 返回值类型 方法名称（参数列表）{ 方法体 }

// 注意：
//     private的方法只有接口自己才能调用，不能被实现类或别人使用

七、多态：

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

代码中体现多态性，其实就是一句话：

父类引用指向子类对象

// 格式：
父类名称 对象名 = new 子类名称();

//或者：
接口名称 对象名 = new 实现类名称();

// 使用多态的写法
// 左侧父类的引用，指向了右侧子类的对象
Fu obj = new Zi();

访问成员变量的两种方式：

1、直接通过对象名称访问成员变量：

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

2、间接通过成员方法访问成员变量：

看该方法属于谁，优先用谁，没有则向上找

#成员变量不可以覆盖重写，成员方法可以

口诀：编译看左边，运行还看左边

成员方法的访问规则：

1、在多态的代码当中，看new的是谁，就优先用谁，没有则先上找

口诀：编译看左边，运行看右边

八、对象转型：

对象向上转型：

其实就是多态写法

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

含义：右侧创建了一个子类对象，把它当作父类来看待使用

注意事项：向上转型一定是安全的，类似于有自动类型转换

对象向下转型：

其实是一个还原转换

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

含义：将父类对象【还原】为本来的子类对象

注意事项：

必须保证对象本来创建的时候的类与将要向下转型的类一致，如果不一致就会报错

如何才能知道一个父类引用的对象，本来是什么子类？

对象 instanceof 类名称

这将会得到一个Boolean值结果，也就是判断前面的对象能不能当作后面类型的实例

九、final关键字：

final关键字代表最终、不可改变的

1、final关键字用来修饰一个类：

public final class 类名称 {
    // ...
}

当前这个类不能有任何子类

一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写

2、final关键字用来修饰一个方法：

final 返回值类型 方法名称(参数列表) {
    // ...
}

此方法无法再被更改或者覆盖重写

3、final关键字用来修饰一个局部变量：

final 数据类型 数据名称 = 数据值

此变量无法更改

4、final关键字用来修饰一个成员变量：

此变量照样无法改变

a、由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值

b、对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值