首页 > 其他分享> > 050_面向对象

050_面向对象

2020-11-09 10:02:54 作者：互联网

面向对象

面向对象

https://www.bilibili.com/video/BV12J41137hu/?p=60

面向对象定义

面向对象编程 OOP Object Oriented Programming
面向对象编程的本质：以类的方式组织代码，以对象的方式组织（封装）数据。
抽象
三大特性
1. 封装
2. 继承
3. 多态

类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
对象是抽象概念的具体实例。

创建与初始化对象

使用new关键字创建对象。

使用new关键字创建对象的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
类中的构造器也成为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点。
1. 必须和类的名字相同。
2. 必须没有返回类型，也不能写void。
使用new关键字，本质是在调用构造器，初始化对象的值。
默认会存在隐式无参构造器。
一旦写了有参构造器，隐式构造器就不存在了，必须也写无参构造器，否则无参new会报错。
idea中Alt+insert，生成构造器。

package com.oop.demo01;

public class Person {
    private String name;
    private int age;
}

package com.oop.demo01;

public class Person {
    private String name;
    private int age;

    public Person() {
    }
}

创建对象内存分析。

对象是通过引用来操作的，栈-->堆。

属性：字段 Field 成员变量默认初始化

数字： 0 0.0
char：u0000
boolean：false
引用：null

类

静态的属性属性
动态的行为方法

封装

高内聚低耦合

高内聚就是类的内部数据操作细节自己完成，不允许外部干涉。
低耦合就是仅暴露少量的方法给外部使用。
属性私有 get/set。

封装的意义

提高程序的安全性，保护数据。
隐藏代码的实现细节。
统一接口。
提高程序可维护性。

继承

Java中类只有单继承，没有多继承。
继承是类和类之间的一种关系。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。
子类继承父类，使用关键字extends来表示。
子类和父类之间，从意义上讲应该具有"is a"的关系。

package com.oop.demo01;

public class Student extends Person {
    private int grade;
}

package com.oop.demo01;

public class Student extends Person {
    private int grade;

    public Student() {
    }
}

Object

在Java中，所有的类都默认之间或间接继承Object。

super

super调用父类的属性和方法，只能出现在子类的方法或构造方法中。
super()调用父类的构造方法，必须在构造方法的第一行。
super()和this()不能同时调用构造方法。
this，本身对象的引用。
super，父类对象的引用。

public class Student extends Person {
    private int grade;

    public Student() {}

    public Student(int grade) {
        super();
        this.grade = grade;
    }

    public Student(String name, int age, int grade) {
        super(name, age);
        this.grade = grade;
    }
}

方法重写

需要有继承关系，子类重写父类的方法。
重写不能是静态方法，静态方法随类加载。
方法名必须相同且参数列表必须相同。
修饰符可以扩大，不能缩小。public>protected>default>private
抛出的异常可以缩小，不能扩大。

package com.oop.demo01;

public class A {

    public void test() {
        System.out.println("A=>test");
    }
}

package com.oop.demo01;

public class B extends A {
    @Override
    public void test() {
        System.out.println("B=>test");
    }
}

B=>test
B=>test

多态

多态即同一方法可以根据调用对象的不同采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用类型有很多（本身，父类，父类的父类...）。
父类的引用指向子类。
对象能执行那些方法，看对象的引用类型。
子类重写方法后，父类引用和子类引用都执行子类方法。

//对象能执行那些方法，看对象的引用类型。
//父类引用a只能调父类A的方法，子类引用b可以调父类A和子类B的方法，子类引用c可以调父类A和子类C的方法。
//如果子类重写父类方法，都执行子类方法。
A a = new B();
B b = new B();
A c = new C();

多态存在的条件

有继承关系。
子类重写父类的方法。
父类引用指向子类对象。

不能多态的方法

static 方法，属于类，他不属于实例。
final
private方法。

instanceof

判断对象类型。
对象是否是类的实例或类的子类的实例或类的子类的子类...的实例。

public static void main(String[] args) {
        //Object > String
        //Object > Person > Student
        //Object > Person > Teacher
        Object object = new Student();

        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false
        System.out.println("=============================");

        Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//false
//        System.out.println(person instanceof String);//编译报错
        System.out.println("=============================");

        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
//        System.out.println(student instanceof Teacher);//编译报错
//        System.out.println(student instanceof String);//编译报错
    }

引用类型转换

引用类型之间的转换：父类子类
子类转父类自动转换。Object object = person;
父类转子类强制转换。Student b = (Student) person;
子类转为父类，只能调用父类的方法。

Person person = new Student();
Object object = person;
Student b = (Student) person;

static

静态变量：static修饰的变量，也叫类变量。

static int age;
//静态变量的调用
System.out.println(Person.age);

静态方法：static修饰的方法。
1. 静态方法不能调用非静态方法，因为静态方法随类加载，静态方法加载时非静态方法还没有加载。
2. 非静态方法可以调用静态方法。
3. 静态方法不能调用非静态变量。
4. 非静态方法可以调用静态变量。

public static void test(){}

静态代码块：类加载时执行一次。

package com.oop.demo01;

public class Demo {
    //执行顺序：2 一般用来赋初始值
    {
        System.out.println("匿名代码块");
    }
    //执行顺序：1 只执行一次
    static {
        System.out.println("静态代码块");
    }
    //执行顺序：3
    public Demo() {
        System.out.println("无参构造方法");
    }

    public static void main(String[] args) {
        Demo demo1 = new Demo();
        System.out.println("=======================");
        Demo demo2 = new Demo();
    }
}

静态代码块
匿名代码块
无参构造方法
=======================
匿名代码块
无参构造方法

静态导入包

import static java.lang.Math.random;

抽象类

abstract修饰方法，该方法就是抽象方法。
abstract修饰类，该类就是抽象类。
抽象类中可以没有抽象方法，但有抽象方法的类一定是抽象类。
抽象类中可以有普通方法。
抽象类有默认的无参构造方法。
抽象类，不能使用new关键字来创建对象，它是用来让子类继承的。
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
子类继承抽象类，必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

package com.oop.demo02;

//抽象类
public abstract class Action {
    //抽象方法
    public abstract void test();
}

package com.oop.demo02;

//继承了抽象类的正常类，必须实现抽象类的所有没有实现的抽象方法
//继承了抽象类的抽象类，可以不实现抽象类的抽象方法
public class ActionA extends Action {
    @Override
    public void test() {

    }
}

接口

普通类：只有具体的实现。
抽象类：具体实现和规范（抽象方法）都有。
接口：只有规范。
接口不能被实例化，因为接口中没有构造方法。
接口中的所有属性都是常量，默认 public static final
接口中的所有方法其实都是抽象的，默认 public abstract
单继承，多实现：可以实现多个接口，只能继承一个父类。
实现了接口的类，就必须重写接口中的所有方法。

package com.oop.demo03;

//接口,接口都需要有实现类
public interface UserService {
    //接口中的所有属性都是常量，默认 public static final
    int age = 9999;
    //接口中的所有方法其实都是抽象的，默认 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

package com.oop.demo03;

public interface TimerService {
}

package com.oop.demo03;

//单继承，多实现
//可以实现多个接口，只能继承一个父类
//实现了接口的类，就必须重写接口中的所有方法
//实现类
public class UserServiceImpl implements UserService,TimerService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}

内部类

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

成员内部类

成员内部类可以使用外部类的所有非静态属性和方法，包括私有的。

package com.oop.demo04;

public class Outer {
    private int id = 10;
    private void out() {
        System.out.println("这是外部类的方法");
    }
    //成员内部类
    public class Inner {
        public void in() {
            System.out.println("这是内部类的方法");
        }
        //内部类可以使用外部类的私有属性和方法
        public void getId() {
            System.out.println("内部类输出外部类私有属性：" + id);
            out();
        }
    }
}

package com.oop;

import com.oop.demo04.Outer;

//一个项目应该只有一个main方法
public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
//        outer.out();
        //通过外部类实例来实例化内部类，内部类必须是public
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getId();
    }
}

静态内部类

静态内部类可以使用外部类的静态属性和静态方法，不能使用非静态属性和方法。

package com.oop.demo04;

public class Outer {
    private static int id = 10;
    private static void out() {
        System.out.println("这是外部类的方法");
    }
    //静态内部类
    public static class Inner {
        public void in() {
            System.out.println("这是内部类的方法");
        }
        //内部类可以使用外部类的私有属性和方法
        public void getId() {
            System.out.println("内部类输出外部类私有属性：" + id);
            out();
        }
    }
}

局部内部类

package com.oop.demo04;

public class Outer {
    public void out() {
        //局部内部类
        class Inner {
            
        }
        System.out.println("这是外部类的方法");
    }
}

匿名内部类

标签：子类,void,System,面向对象,println,050,public,out
来源： https://www.cnblogs.com/wl3pb/p/13947081.html