Java面向对象复习(持续更新中)

Java面向对象复习(暂时断更,最近有点忙)

前言

此资料用于学过了，但还是有点欠缺或需要复习或是作为一份入门的资料使用，第一次做复习资料有不足如果有什么不对的地方请各位大佬指出（基本都是根据自身学习的东西来的）。可能过二个月左右会大幅度更新吧

概念

java的核心思想就是OOP

面向过程 & 面向对象

• 面向过程：线性思维，步骤清晰简单，第一步做什么，第二步做什么，适合处理简单的问题。
• 面向对象：分类的思维模式，首先解决问题需要分那些类，然后对分类进行独立思考。面向对象适合处理复杂问题，适合处理多人协作问题。

什么是面向对象

• 面向编程本质就是：以类的方式组织代码，以对象组织(封装)数据
• 抽象
• 三大特性
  • 封装
  • 继承
  • 多态

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

封装的意义：

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

继承：继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。extends的意思是“扩展”，子类是父类的扩展。java是只有单继承而没有多继承的。

• 继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、聚合、组合等。
• 继承关系的二个类，一个为子类(派生类)，一个为父类(基类)。

//调用父类的构造器，必须要再子类的第一行，默认调用无参
//只能出现再子类的方法或构造方法内，super不能和this同时调用构造方法
super();

super与this的区别：

1. 代表对象不同，this本身是调用这个对象的，super代表父类的调用
2. 前提：this没有继承也能使用，super必须要继承条件才能使用
3. 构造方法：this本类构造,super父类构造 

方法的重写：需要子类继承父类，重写父类的方法，方法名必须相同，参数列表必须相同，修饰符：范围可以扩大，抛出的异常可以缩小但是不能扩大

为什么需要重写：子类不一定需要，或不满足。

**多态：**即同一方法可以根据发送对象的不同而采用多种不同的行为方式，简单的理解就是一种事物的不同形态如：水、冰类的，一个对象的实际类型是可以确定的，但指向的引用类型可以有很多。注意多态是方法的多态而不是属性的多态。

多态存在的条件：

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

//类型转换，引用类型判断是否存在父子关系
instanceof
//System.out.println(x instanceof y);能不能编译通过

//随便记得一些东西
//静态导入包
import static java.lang.Math.random;//随机数
System.out.print(random());//直接使用
//以前的方法没有用静态导入
System.out.print(Math.random());

抽象类

//abstract关键字声明一个抽象类
//用在类上就是抽象类，方法上就是抽象方法，抽象方法只有抽象方法，没有方法实现
//抽象类的方法继承了他的子类必须要去实现他的所有方法
//这里就可以看出我们继承的局限性了，java继承只能实现单继承不能多继承
//1. 抽象类是不能被new的只能继承去实现约束
//2. 抽象类可以写普通方法，而抽象方法必须在抽象类中
public abstract void doMain();

接口

普通类：只有具体的实现

抽象类：具体实现和规范(抽象方法)都有

接口：只有规范，自己无法写方法-专业的约束。约束和实现的分离：面向接口编程

//关键字interface

1、定义接口时使用interface定义，区别于抽象类，不需要加class。
2、接口不能被实例化，不能直接创建对象，因为接口里面只有抽象的方法，没有具体的功能。
3、接口可以继承接口，接口要实现具体的功能必须有实现他的子类，实现接口的子类中必须重写接口全部的抽象方法。
4、接口和接口之间可以多继承。
5、接口的子类可以是抽象类，但是没有实际的意义。
6、一个子类可以实现多个接口，通过implements关键字去实现。
7、接口需要通过多态才能创建对象。

内部类(这个当初学的时候没怎么听)

• 内部类就是在类的内部再定义一个类
  • 成员内部类
  • 静态内部类
  • 局部内部类
  • 匿名内部类

//内部类可以用来访问外部类的方法
public class Applications {
    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);
        }
    }
}
//实现类
public class  ApplicationsTest{
    public static void main(String[] args) {
        Applications applications=new Applications();
        //通过外部类获取内部类
        Applications.Inner inner = applications.new Inner();
        inner.in();
        inner.getID();
    }
}
//注意如果内部类方法为静态的，则不能访问到数据，除非数据也是静态的
//一个类中可以有多个class文件，但是只能有一个public clas类

//局部内部类
    public void method(){
        class Inner{

        }
    }

//还可以这样
public class Mapper {
    public static void main(String[] args) {
        //没有名字初始化类，不用实例保存到变量中
        new Apper().eat();

        UserMapper userMapper=new UserMapper() {
            @Override
            public void hello() {

            }
        };
    }
}

class Apper{
    public void eat(){
        System.out.println("eat");
    }
}

interface UserMapper{
    void hello();
}