【JavaSE】之面向对象编程

---

前言

本文为Java基础面向对象编程相关知识，Java全栈学习路线可参考：【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引，内含最全Java全栈学习技术清单~

一、认识面向对象

1.面向过程&面向对象

面向过程思想

• 步骤清晰简单，第一步做什么，第二步做什么….
• 面对过程适合处理一些较为简单的问题

面向对象思想

• 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
• 面向对象适合处理复杂的问题，适合处理需要多人协作的问题!

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

2.什么是面向对象

• 面向对象编程(Object-Oriented Programming, OOP)
• 面向对象编程的本质就是:以类的方式组织代码，以对象的形式封装数据
• 抽象：编程思想!持续的学习，茅塞顿开!多实践,多测试大脑中的想法!实践出真知
• 三大特性：封装，继承，多态
• 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
• 从代码运行角度考虑是先有类后有对象。类是对象的模板

二、对象的创建与分析

1.类与对象的关系

类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物.

• 动物、植物、手机、电脑….
• Person类、Pet类、 Car类等, 这些类都是用来描述/定义某一类具体的事物应该具备的特 点和行为

对象是抽象概念的具体实例

• 张三就是人的一个具体实例,张三家里的旺财就是狗的一个具体实例。
• 能够体现出特点,展现出功能的是具体的实例,而不是一个抽象的概念.

我们可以将这种思想转换为代码实现!

2.对象创建与初始化

• 使用new关键字创建对象
• 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用
• 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:1.必须和类的名字相同；2.必须没有返回类型,也不能写void
• 构造器必须要掌握

代码示例：

//学生类
public class Student {
    //属性:字段
    String name;//没有赋值，默认为null
    int age;//没有赋值，默认为0
    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}

//一个项目应该只存一个main方法
public class Application {
    public static void main(String[] args) {
        //类:抽象的，要实例化
        //类实例化后会返回一个自己的对象!
        //student对象就是一个Student类的具体实例!
        Student student = new Student();
        student.name = "张三";
        student.age = 18;
        System.out.println(student.name);
        System.out.println(student.age);
    }
}

3.构造器

• 构造器：和类名相同；没有返回值
• 作用：new本质在调用构造方法；初始化对象的值
• 注意点：定义有参构造之后，如果想使用无参构造，需要显示的定义一个无参的构造

代码示例：

public class Person {
    //一个类即使什么都不写，它也会存在一个方法
    //显示的定义构造器
    String name;
    //实例化初始值
    //1.使用new关键字，本质是在调用构造器
    public Person(){
//        this.name = "张三";
    }
    //有参构造:一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name = name;
    }
}

//一个项目应该只存一个main方法
public class Application {
    public static void main(String[] args) {
        //new实例化了一一个对象
        Person person = new Person("李四");
        System.out.println(person.name);
    }
}

三、面向对象三大特征

1.封装

• 我们程序设计要追求“高内聚，低耦合”。高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
• 封装(数据的隐藏)：通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。记住这句话就够了:属性私有，get/set
• 封装的优点：1.提高程序的安全性，保护数据；2.隐藏代码的实现细节；3.统一接口；4.系统可维护增加了

代码示例：

// Student类

public class Student {
    //属性私有
    private String name;//名字
    private int age;//年龄
    private int idCard;//学号
    private char sex;//性别
    //提供一些可以操作这个属性的方法!
    //提供一些public 的get、set方法
    //get获得这个数据
    public String getName() {
        return name;
    }
    //set给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if (age>120||age<0){ //不合法
            this.age = 3;
        }else{
            this.age = age;
        }
    }
    public int getIdCard() {
        return idCard;
    }
    public void setIdCard(int idCard) {
        this.idCard = idCard;
    }
    public char getSex() {
        return sex;
    }
    public void setSex(char sex) {
        this.sex = sex;
    }
    //学习（）
    //睡觉（）
}

// Application类
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("李白");
        System.out.println(s1.getName());
        s1.setAge(99);
        System.out.println(s1.getAge());
    }
}

2.继承

• 继承是类和类之间的一种关系。除此之外类和类之间的关系还有依赖、组合、聚合等
• 继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。 子类继承父类,使用关键字extends来表示
• 子类和父类之间,从意义上讲应该具有”is a”的关系

super注意点:

• sulper调用父类的构造方法，必须在构造方法的第一个
• super必须只能出现在子类的方法或者构造方法中
• super和 this不能同时调用构造方法

super与this比较:

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

重写

• 重写:需要有继承关系，子类重写父类的方法!
• 方法名必须相同
• 参数列表列表必须相同
• 修饰符:范围可以扩大但不能缩小:public>Protected>Default>private
• 抛出的异常:范围，可以被缩小，但不能扩大;ClassNotFoundException —>Exception(大)
• 重写，子类的方法和父类必要一致;方法体不同
• 为什么需要重写:父类的功能，子类不一定需要，或者不一定满足

代码示例：

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

// 子类（A）
public class A extends B{
    //Override重写
    @Override //注解:有功能的注释!
    public  void test(){
        System.out.println("A==>test()");
    }
}

// Application
public class Application {
    public static void main(String[] args) {
        //静态的方法和非静态的方法区别很大!
        //方法的调用只和左边，定义的数据类型有关
        A a = new A();
        a.test();
        //父类的引用指向了子类
        B b = new A();
        b.test();
        /*
        输出结果:
            A==>test()
            A==>test()
        */
    }
}

父类中不能被重写的方法有：

• 带static修饰的方法（static方法属于类，不属于实例）
• 带final修饰的方法（final常量修饰符）
• 带private修饰的类，私有类不能重写

3.多态

• 多态即同一方法可以根据发送对象的不同而采用多种不同的行为方式
• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
• 多态存在的条件：有继承关系；子类重写父类方法；父类引用指向子类对象
• 注意:多态是方法的多态，属性没有多态性
• instanceof (类型转换)引用类型

代码示例：

// Person类
public class Person {
    public void run(){
        System.out.println("run");
    }
}

// Student类
public class Student extends Person{
    @Override
    public void run(){
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}

// Application类
public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();
        //可以指向的引用类型就不确定了:父类的引用指向子类
        //Student能调用的方法都是自己的或者继承父类的!
        Student s1 = new Student();
        //Person父类型，可以指向子类，但是不能调用子类独有的方法(只能将父类强制转换成子类对象才能调用)
        //父类引用指向子类对象，
        //在父类new子类，调用时是调用父类，要是子类重写了父类，则调用子类方法
        Person s2 = new Student();
        Object s3 = new Student();
        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大!
        s2.run();//子类重写了父类的方法，执行子类的方法
        ((Student) s2).eat();
        s1.run();
    }
}

多态注意事项：

• 多态是方法的多态，属性没有多态
• 父类和子类，有联系 类型转换异常! ClassCastException!
• 存在条件: 继承关系，方法需要重写，父类引用指向子类对象! Father f1 = new Son()

多态的总结

• 父类引用指向子类的对象
• 把子类转换为父类，向上转型
• 把父类转换为子类，向下转型; 强制转换
• 方便方法的调用，减少重复的代码
• 简洁 封装、组承、多态! 抽象类，接口

4.static的使用

静态变量与方法

//static
public class Student {
    public static  int age;//静态变量   大多只会出现在多线程
    private double score;//非静态变量
    //下面这个是非静态方法
    public void run(){
        System.out.println("run");
        //go();//非静态方法里可以调用静态方法
    }
    //下面这个是静态方法
    public static void go(){
        System.out.println("go");
    }
    public static void main(String[] args) {
        Student s1 = new Student();
        //静态变量对于类，所有对象（实例）所共享，当直接使用类名去调用变量名，说明这个变量名是static（静态）的
        System.out.println(Student.age);
        //System.out.println(Student.score);会报错，提示score是非静态变量，无法用类名调用。
        System.out.println(s1.age);
        System.out.println(s1.score);
        System.out.println("========================");
        /*
        s1.run();(想使用run()方法，就必须new一个Student，即new一个对象,调用的写法只能是 对象名称.方法名)
        go();(即使没有new一个Student，也可以直接调用go()方法，)
        Student.go();(也可以在go()方法前面加类名，也可以像上面一样不加类名,(不加类名的前提是必须在同一个类下面))
        */
    }
}

匿名代码块/静态代码块

//当下面public class Person写成public final class Person时，表示当前类不能被继承
//final有最终的意思
public class Person {
    //第二个执行，每new一次对象就会执行一次(可以用来赋初始值)
    {
        System.out.println("匿名代码块");
    }
    //第一个执行，并且只执行一次
    static {
        System.out.println("静态代码块");
    }
    //第三个执行，每new一次对象就会执行一次
    public Person() {
        System.out.println("无参构造方法");
    }
    public static void main(String[] args) {
        Person person = new Person();
        /*
        输出结果：
                静态代码块
                匿名代码块
                无参构造方法
         */
    }
}

静态导入包

//静态导入包~
import static java.lang.Math.random;
public class Test {
    public static void main(String[] args) {
        //System.out.println(Math.random());//静态导入包的方法之后，连类名都可以不写了
        System.out.println(random());
        System.out.println(Math.PI);//这里没导入包的方法，所以要写Math
    }
}

四、抽象类与接口

1.抽象类

• abstract修饰符可以用来修饰方法也可以修饰类：如果修饰方法,那么该方法就是抽象方法；如果修饰类,那么该类就是抽象类。
• 抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
• 抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。
• 抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
• 子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。
• 抽象类中存在无参构造方法。

代码示例 ：

// 抽象类Action
public abstract class Action {
    //约束~有人帮我们实现~
    //abstract，抽象方法，只有方法名字，没有方法的实现!
    public abstract void doSomething();
    //1.不能new这个抽象类，只能靠子类去实现它;约束!
    //2.抽象类中可以写普通的方法
    //3.抽象方法必须在抽象类中
    public void run(){
        System.out.println("run");
    }
}

// 普通类A继承抽象类Action
//抽象类的所有方法，继承了它的子类，都必须要实现它的方法~（重写父类的方法），除非把这个类也设置为抽象类
public class A extends Action {
    @Override
    public void doSomething() {
    }
}

2.接口

• 普通类: 只有具体实现
• 抽象类: 具体实现和规范(抽象方法)都有!
• 接口: 只有规范! 自己无法写方法~专业的约束! 约束和实现分离: 面向接口编程~
• 接口就是规范，定义的是一组规则，体现了现实世界中“如果你…则必须能…的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人;如果你是坏人，则必须欺负好人。
• 接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
• OO的精髓，是对对象的抽象，最能体现这一点的就是接口。 为什么我们讨论设计模式都只针对具备了抽象能力的语言(比如c++. java、c#等) ，就是因为设计模式所研究的，实际上就是如何合理的去抽象。
• 注意：声明类的关键字是class  声明接口的关键字是interface

// 接口UserService
//interface 定义的关键字  接口都需要有实现类
public interface UserService {
    //接口中的所有定义其实都是抽象的public abstract
    //返回值类型+参数名+(参数有就写，没有就不写)
    /*
    void shout();
    void run(String name);
    */
    //常量~ public static final
    int AGE = 99;
    //接口中的所有定义的方法其实都是抽象的public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

// 接口TimeService
public interface TimeService {
    void timer();
}

// 普通类UserServiceImpl实现（也叫继承）UserService,TimeService
//抽象类   extends 只能单继承
//类可以实现接口   implements 接口名  （implement可以多实现，也叫多继承）
//实现了接口的类，就需要重写接口中的方法
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() {
    }
}

接口的作用

• 约束
• 定义一些方法，让不同的人实现~ 10—- >1
• public abstract  成员方法
• public static final  成员变量
• 接口不能被实例化，接口中没有构造方法
• implements可以实现多个接口
• 必须要重写接口中的方法

五、内部类

1.内部类的概念与分类

• 内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。
• 内部类的分类：1.成员内部类；2.静态内部类；3.局部内部类；4.匿名内部类。

2.成员内部类

public class Outer {
    private int id = 10;
    public void out(){
        System. out. println("这是外部类的方法");
    }
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性~
        public void getID(){
            System.out.println(id);
        }
    }
}

Application

public class Application {
    public static void main(String[] args) {
        //new
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();
    }
}

3.静态内部类

public class Outer {
    private int id = 10;
    public void out(){
        System. out. println("这是外部类的方法");
    }
    public static class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
    }
}

Application

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
    }
}

4.局部内部类

public class Outer {
    //局部内部类(方法里面写一个类)
    public void method( ){
        class Inner {
            public void in() {
            }
        }
    }
}
//一个java类中可以有多个class类， 但是只能有一个public class
/*class A{
    public static void main(String[] args) {
    }
}*/

5.匿名内部类

public class Test {
    public static void main(String[] args) {
        /*
        正常情况下我们想调用Apple类中eat方法，我们会先new一个对象，然后初始化类
        Apple apple = new Apple();
        然后用对象名调用eat
        apple.eat();
        但是这里我们不需要去初始化，直接new
        */
        //没有名字初始化类,不用将实例保存到变量中
        new Apple().eat();
        //下面的也叫匿名内部类
        //new UserService()其实是长这样， UserService userService =  new UserService()
        new UserService(){
            @Override
            public void hello() {
            }
        };
    }
}
class Apple {
    public void eat() {
        System.out.println("1");
    }
}
interface UserService{
    void hello();
}

后记

Java全栈学习路线可参考：【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引，内含最全Java全栈学习技术清单~