面向对象

初识面向对象

• 面向对象编程（Object-Oriented Programming,OOP）

• 面向对象编程的本质是：一类的方式组织代码，以类的方式组织代，以对象的组织（封装）数组

• 面向对象的三大特征

  封装

  继承

  多态

方法回顾和加深

方法定义

• 修饰符

• 返回类型

• break（跳出switch循环）和return

• 方法名

• 参数列表

• 异常抛出

方法的调用

• 静态方法
• 非静态方法
• 形参和实参
• 值传递和引用传递
• this关键字

对象的创建分析

• 使用new关键字来创建对象

• 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用

• 类中的构造器也称为构造方法，时进行创建对象的时候必须调用的。并且构造器有以下两个特点：

  1.必须和类名相同

  2.必须没有返回类型，也不能写void

面向对象的三大特征

封装

• 该露的露，该藏的藏：高内聚，低耦合
• 封装，数据的隐藏
• 属性私有，get/set

public class Student {
    //属性：字段
    private String name;
    private int age;
    private String flag;
    //提供一些可以操作这个属性的方法
    //提供一些public的get和set的方法
    public String getName(){
        return this.name;
    }
    public void setName(String name){
         this.name=name;
    }
}

 public static void main(String[] args) {
        //类是抽象的
        Student student = new Student();
        student.setName("sww");
        System.out.println(student.getName());
    }
------------------------
    sww

• 意义

  1.提高程序安全性，保护数据

  2.隐藏代码实现的细节

  3.统一接口

  4.提高系统的可维护性

继承（ctrl+h打开继承关系）

在Java中所有的类都默认继承object类

public（公共的）、 protected（受保护的）、 default（默认的）、 private（私有的）

• 继承的本质是对某一批的抽象，从而实现对现实世界更好的建模
• extends的意思是扩展，子类是父类的扩展
• Java中只有单继承，没有多继承！
• 继承是类和类之间的一种关系。除此之外，类和类之间还有依赖、组合、聚合等。
• 继承关系的两个类，一个为父类，一个为派生类。子类继承父类，使用该关键字extend来表示

super注意点

• 可以调用父类的一些属性和方法。
• 无参构造方法首先默认调用父类的构造器，而且必须在子类构造器的第一行
• 必须只能出现在子类的方法和构造方法中
• super和this不能同时调用构造方法

方法重写

• 静态方法：方法调用只和左边定义的数据类型有关

• 只有非静态的方法才能重写

• 只有共有的public修饰的方法才能有重写

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

  1.方法名必须相同

  2.参数列表必须相同

  3.修饰符：范围只能扩大 public>protected>default>private

  4.抛出的异常：范围可以被缩小但不能被扩大

多态

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

public static void main(String[] args) {
   //一个对象的实际类型是确定的
    //new Student();
    //new Persion();
    //可以指向的引用类型就不确定了：父类的引用指向子类
    //Student能调用的方法都是自己的或者继承父类的
    Student s1 = new Student();
    //Person父类型，可以指向子类但是不能调用独有的方法
    Person s2 = new Student();
    Object s3= new Object();
    s1.run();
    s2.run(); //子类重写了父类的方法
}

• 注意事项

  1.多态是方法的多态，属性没有多态

  2.父类和子类，有联系，类型转换异常 ClassCastException

  3.多态存在的必要条件：继承关系，方法重写，父类的引用指向子类对象father f1==》new Son();

• 不能被重写的方法

  1.static方法，属于类，它不属于实例

  2.fianl常量

  3.private不能被重写

类型转换（引用类型） instanceof

• 判断一个对象是什么类型用instanceof

public static void main(String[] args) {
    Object object = new Student();
    System.out.println(object instanceof Student);
    System.out.println(object instanceof Teater);
    System.out.println(object instanceof Person);
    System.out.println(object instanceof String);
    System.out.println(object instanceof Object);
}
-------------------------------------------------------------------
true
false
true
false
true

• 子类向父类转型，不需要强转。
• 父类向子类需要强转，但可能会丢失一些自己本来的方法
• 方法调用，减少代码重复

static

通过final修饰的类就不能有子类了，final之后断子绝孙

private static int age; //静态变量
private double score;//非静态变量

public static void run(){
}
public void go(){
    run();
}
public static void main(String[] args) {
    Student student = new Student();
    System.out.println(student.score);
    System.out.println(Student.age);
    run();
}

import static java.lang.Math.random;

//2.赋初始值
{
    System.out.println("匿名代码块");
}
//1.类加载的时候就有，只执行一次，第二次输出就没有
static {
    System.out.println("静态代码块");
}
//3
public Student() {
    System.out.println("构造方法");
}

public static void main(String[] args) {
    Student student = new Student();
     System.out.println(Math.random());//每次很麻烦，我们只想每次用random，运用静态导入包
}
------------------------------------------------
静态代码块
匿名代码块
构造方法

抽象类和接口

抽象类

• abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。

//abstract 抽象类：类 extend：只能单继承，但接口可以实现多继承
public abstract class Action {

    //约束~有人帮我们实现
    //abstract抽象方法，只有方法的名字没有方法的实现
    public abstract void doSomething();
    //抽象类不能new出来，只能靠之类能实现他
}

//抽象类的方法，继承了他的子类，都必须要实现他
public class A extends Action{

    @Override
    public void doSomething() {

    }
}

• 抽象类中可以没有抽象方法，但抽象方法的类一定要声明为抽象类
• 抽象类，不能使用new关键字来创建对象，他是用来子类继承的
• 抽象方法，只有方法声明，没有方法实现，他用来让子类实现的
• 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明抽象类

接口

• 普通类：只有具体实现
• 抽象类：具体实现和规范（抽象方法）都有
• 接口：只有规范 约束和实现分类

public interface TimeSevice {

}

public interface Demo09 {
   //接口中的所有定义都是抽象的
    public void add(String name);
    public void del(String name);
    public void update(String name);
    public void select(String name);
}

//抽象类：extends
//类 可以实现接口 implements 接口
//实现了接口中的类，就需要重写接口中的方法
//利用接口实现多继承
public class UserServiceImpl implements Demo09,TimeSevice{

    @Override
    public void add(String name) {
        
    }

    @Override
    public void del(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void select(String name) {

    }

• 作用

  1.约束

  2.定义一些方法，让不同的人来实现

  3.方法都是public abstract

  4.接口不能被实例化的，接口中没有构造方法

内部类及OOP实战

内部类

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

• 成员内部类

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

        public void getId() {
            System.out.println(id);
        }
    }
}

public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getId();
    }
---------------------------------------------------------
这是内部类的方法
10

• 静态内部类
• 局部内部类

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

    }

• 匿名内部类