面向对象编程oop

面向对象

思想

• 物以类聚，分类的思维模式。分类，然后对这些分类进行单独思考，最后对某个分类下的细节进行面向过程

对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是具体到微观的操作，仍然需要面向过程的思路去处理。

面向对象编程OOP

• 本质：以类的方式组织代码，以对象的组织（封装）数据

抽象：编程思想

三大特性

封装

• 信息隐藏：应禁止直接访问一个对象中数据的实际表示，而应通过接口操作来访问
• 属性私有，get/set

作用：

1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 增加系统可维护性

//类
//封装的核心关键字：private 私有
public class Student {
    //属性私有
    private String name;//名字
    private int id;    //学号
    private char sex;   //性别
    private int age;  //年龄

    //提供一些可以操作这些属性的方法
    //提供一些public的get、set方法

    //get 获得这个数据
    public int getAge() {
        return age;
    }

    //set 给这个数据设置值
    public void setAge(int age) {
        if(age>120||age<0){//在方法里加上判断逻辑，是否数据合法
            System.out.println("年龄不合法");
        }else{
            this.age = age;
        }
    }
    //快捷键：alt + insert 自动生成get、set方法

继承

• 继承的本质是堆某一批类的抽象，从而实现对现实世界更好的建模
• extands：扩展。子类是父类的扩展
• Java中类只有单继承，没有多继承，一个儿子只有一个爸爸，一个爸爸可以有多个儿子
• 继承是类间关系，还有依赖、组合、聚合等
• 被final修饰的类不能继承
• Ctrl+H -->查看继承树

//在Java中，所有类都默认继承Object类
//人类 :父类
public class Person {

    //public
    public void say(){
        System.out.println("说了一句话");
    }
    //private
    private int money = 10_0000_0000;
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
}

//学生 is 人
//子类继承了父类所有public的东西,private的东西无法继承
public class Student extends Person {
    //Ctrl + H  -->继承树
}
/*
    public static void main(String[] args) {
        Student student = new Student();
        student.say();//继承了父类
    }
 */

super类，对比this

public class Person {
    public Person() {
        System.out.println("Person无参构造执行");
    }
    protected String name = "狂神";
    public void print(){
        System.out.println("Person");
    }
}

public class Student extends Person {
    public Student() {
        //隐藏代码：调用了父类的无参构造    现有父后有子
        //super()[这个代码被隐藏了] 调用父类构造器，必须在子类构造器第一行，不用写默认存在
        System.out.println("Student无参构造执行");
    }
    private String name = "qinjiang";
    public void print(){
        System.out.println("Student");
    }
    public void test(String name){
        System.out.println(name);//秦疆，输出的传递的参数
        System.out.println(this.name);//qinjiang，当前对象的name
        System.out.println(super.name);//狂神,父类的name
    }
    public void test1(){
        print();//Student
        this.print();//Student
        super.print();//Person
    }
}
/*
    public static void main(String[] args) {
        Student student = new Student();
        //Person无参构造执行
        //Student无参构造执行
    }
 */

super注意点：

1. super调用父类的构造方法，必须在构造方法的第一个
2. super必须只能出现在子类的方法或构造方法中
3. super和this不能同时调用构造方法（因为都必须在第一行）

Vs this:

• 代表的对象不同：
  this：本身调用者这个对象
  super：代表父类对象的应用
• 前提
  this：没有继承也可以使用
  super：只能在继承条件才可以使用
• 构造方法
  this（）：本类的构造
  super（）：父类的构造

方法重写

//父类
//重写都是方法的重写，和属性无关
public class B {
    public static void test(){
        System.out.println("B=>test()");
    }
}

static方法重写

//继承
public class A extends B{
    public static void test(){
        System.out.println("A=>test()");
    }
}
/*
    public static void main(String[] args) {
        //static方法的调用 只和左边即定义的数据类型有关
        A a = new A();
        a.test();//A=>test()

        //父类的引用指向了子类
        //A的构造函数中包含了B的构造函数
        B b = new A();
        b.test();//B=>test()
    }
 */

非静态方法

//继承
public class A extends B{
    //Override 重写
    @Override//注解：有功能的注释！
    public void test() {
        System.out.println("A=>test()");
    }
}
/*
    public static void main(String[] args) {
        A a = new A();
        a.test();//A=>test()

        B b = new A();//子类重写了父类的方法（非静态方法）
        b.test();//A=>test()
    }
    //区别与重载，，重载是参数列表不同
 */

重写：需要有继承关系，子类重写父类的方法！

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大（不能缩小） ： public>Protected>Default>private
4. 抛出的异常：范围，可以被缩小，但不能扩大： ClassNotFoundException–>Exception（大）

重写：子类的方法和父类必须一致，但方法体不同！

为什么需要重写：

• 父类的功能，子类不一定需要，或者不一定满足
• 快捷键：Alt + Insert ： override

多态

• 即同一方法可以根据发送对象的不同而采取多种不同的行为方式。
• 一个对象的实际类型是确定的，但是可以指向对象的引用类型有很多（父类，有关系的类）

public class Person {

    public void run(){
        System.out.println("run");
    }
}

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}
/*
    public static void main(String[] args) {

        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型就不确定了: 父类的引用指向子类
        Student s1 = new Student(); //Student 能调用的方法都是自己的或父类的
        Person s2 = new Student(); //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Object s3 = new Student();

        //对象能执行哪些方法，主要看对象左边类型（能否执行看引用类型，执行内容看实际类型）
        s2.run();//子类重写了父类的方法，执行子类的方法 输出son
        ((Student) s2).eat();//强制转换，，Person———》Student 然后就可以调用eat方法
        s1.run();//son
    }
 */

多态注意事项：

1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系 不然会类型转换异常（ClassCastException）
3. 存在条件： 继承关系，方法需要重写，父类引用指向子类对象 Father f1 = new Son（）;

不能被重写的方法：

1. static 方法，属于类，它不属于实例
2. final 常量 （在常量池）
3. private 方法

instanseof 和 (类型转换) 引用类型

• instanceof:可以判断两个类之间是否存在父子关系（有关系为true）

        //类型之间的转换  父  子
        //高                    低
        Person student = new Student();
        //student将这个对象转换会Student类型，就可以使用Student类型方法了
        ((Student)student).go();//高类型 转 低类型 -->强制转换

1. 把子类转换成父类，向上转型
2. 把父类转换为子类，向下转型：强制转换（可能丢失一些方法）
3. 方便方法的调用，减少重复的代码

static关键字

//static
public class Student {
    private static int age;//静态变量
    private double score;//非静态变量
    public void run(){
    }
    public static void go(){
    }
    public static void main(String[] args) {
        Student s1 = new Student();

        System.out.println(Student.age);//Student.age --类变量
        //System.out.println(Student.score);报错，非静态变量，无法用类变量直接得到
        System.out.println(s1.age);
        System.out.println(s1.score);
        Student.go();//也可以直接go();  静态方法 跟类一起加载
        //run();Student.run();不可以，必须使用对象，如s1.run();
    }
}

public class Person {
    {
        //匿名代码块
        System.out.println("匿名代码块");
    }
    static {
        //静态代码块
        System.out.println("静态代码块");
    }
    public Person() {
        System.out.println("构造方法");
    }
    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("===========");
        Person person2 = new Person();
    }
    /*
    静态代码块//和类一起加载，只执行一次
    匿名代码块//对象创建时加载,可以赋一些初始值
    构造方法//创建对象时加载
    ===========
    匿名代码块
    构造方法
     */
}

类与对象的关系

• 类是一种抽象的数据类型，它是对某一类事物的整体描述/定义，但并不能代表某一个具体的事物，如：Person类，Pet类
• 对象是抽象概念的具体实列，如：张三就是人的一个具体实列

方法回顾

//Demo01 类
public class Demo01 {

    //main 方法
    public static void main(String[] args) {

    }

    /*
    修饰符   返回值类型   方法名（...){
           //方法体
           return 返回值; //return表示方法结束，返回一个结果
    }
     */
    public String sayHello(){
        return "hello,world";
    }
    public int max(int a , int b){
        return a>b? a: b;//三元运算符
    }

    //IO流 读文件    抛出异常
    public void readFile(String file) throws IOException {

    }
}

//学生类
public class Student {

    //静态方法
    /*
    类名.方法名  //使用方法
    static方法是和类一起加载的，时间片较早
     */
    public static void say1(){
        System.out.println("学生说话了");
    }

    //非静态方法
    /*
    需要把类实列化 通过new关键字
    非静态方法在类实列化之后才存在
     */
    public  void say2(){
        System.out.println("学生说话了");
    }

}

        Student.say1();//static 静态方法的调用

        //实列化这个Student这个类，然后使用say2方法
        Student student = new Student();//对象类型  对象名 = 对象值；
        student.say2();//调用方法

    //java是值传递
    public static void main(String[] args) {
        int a = 1;

        Demo04.change(a);

        System.out.println(a);//输出a的值为1
    }

    //返回值为空
    public static void change(int a){
        a = 10;
    }

//引用传递： 对象，本质还是值传递
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();//实列化对象
        System.out.println(person.name);//输出null

        Demo05.change(person);
        System.out.println(person.name);//输出秦江
    }

    public static void change(Person person){
        //person是一个对象：指向--->Person person = new Person();这是一个具体的人，可以改变属性
        person.name = "秦江";
    }

}
//一个类只能有一个public class 但是可以有多个class
//定义了一个person类，有一个属性：name
class Person{
    String name;//默认null
}

对象的创建分析

• 类里封装属性和方法

//学生类
public class Student {
    //属性：字段
    String name;
    int age;

    //方法
    public void study(){
        System.out.println(this.name + "在学习");//this表示当前这个类    XXX学生在学习  name可以赋值
    }
}

//一个项目应该只有一个main方法
public class Application {
    public static void main(String[] args) {
        //类是抽象的，咱们要把类实列化
        //实列化后会返回一个自己的对象
        Student student = new Student();//student对象就是Student类的具体实列

        //为对象赋值
        student.name = "小明";
        student.age = 3 ;
        System.out.println(student.name);
        System.out.println(student.age);
        student.study();//小明在学习
    }
}

构造器

public class Person {
    //一个类即使什么都不写，也会存在一个方法（构造器）
    /*
        public Person(){
    }//默认生成
     */


    String name;
    //显示的定义构造器
    public Person(){//无参构造
        this.name = "qinjiang";
    }//作用：实例化初始值

    //有参构造
    public Person(String name){//方法重载
        this.name = name;
    }//一旦定义了有参构造，无参构造必须显示定义（可以为空，但是必须有，不然new会报错）
    /*
    1.使用new关键字，本质是在调用构造器
    2.用来初始化值
     */

    //快捷键alt+insert  ：生成构造器
}
//每一个类的测试类都写注释在最下边
/*
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);//qinjiang
        Person person1 = new Person("kuangshen");
        System.out.println(person1.name);//kuangshen  （走有参构造，因为方法重载）
    }
 */

/*
构造器：
    1.和类名相同
    2.没有返回值
  作用：
    1.new 本质在调用构造方法
    2.初始化对象的值
  注意点：
    1.定义了有参构造后，如想使用无参构造，需要显示定义一个无参构造
  快捷键：alt+insert
  this.XXX(XXX是当前类的) = xxx（xxx是参数传进来的值）
 */

类与对象小结

        /*
        1.类与对象
             类是一个模板，对象是一个具体的实例
        2.方法
             定义、调用
        3.对象的引用
             引用类型： 基本类型（八个）
                对象是通过引用来操作的：栈--->堆
        4.属性：字段Field 成员变量
            默认初始化：
               数字： 0  0.0
               char：  u0000
               boolean： false
               引用： null
           修饰符  属性类型 属性名 = 属性值
        5.对象的创建和使用
            - 必须使用new 关键字创建对象，构造器（必须有）
            - 对象的属性 对象名.属性
            - 对象的方法 对象名.方法名（）
        6.类
            静态的属性   属性
            动态的行为   方法 
         */

抽象类和接口

抽象类

//抽象类，本质是类-->单继承    接口可以实现多继承！
//abstract 抽象类关键字
public abstract class Action {

    //约束~有人帮我们实现
    //abstract 抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();//抽象方法必须在抽象类中

    //特点：
    //1.不能new这个抽象类，只能靠子类去实现它（是约束）
    //2.抽象类可以写普通方法
    //3.抽象方法必须在抽象类中
}
/*
//抽象类的所有方法，继承了它的子类，都必须要实现它的方法（方法重写）
public class A extends Action{
    @Override
    public void doSomething() {

    }
}
 */

接口

• 普通类：只有具体实现
• 抽象类：具体实现和规范（抽象方法）都有
• 接口：只有规范！自己无法写方法！专业的约束（约束和实现分离）：面向接口编程~

接口的本质是契约。

//interface 接口关键字
//接口都需要有实现类
public interface UserService {
    //接口中的所有定义都是抽象的 public abstract（默认）
    void add(String name);//实际是public abstract void add(String name)；
    void delete(String name);
    void update(String name);
    void query(String name);
    //接口里定义的属性都是常量,一般不会这样做
    int AGE = 99;//实际是public static final int AGE = 99；
}

//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法
//多继承~利用接口实现多继承（两个接口类：UerService，TimeService）
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {//TimeService里的

    }
}

作用：

1. 约束
2. 定义一些方法，让不同的人实现
3. public abstract
4. public static final
5. 接口不能被实例化，接口中没有构造方法
6. implements可以实现多个接口
7. 必须重写接口中的方法

内部类

• 内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对于A类来说就称为内部类。而A类相对B类来说就是外部类了。

1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类：不用将实例保存到变量中，可以直接new 类名().方法()；

• 一个java类中可以有多个class类，但是只能有一个public class