java入门（六）面向对象

java入门（六）面向对象

java的核心思想就是面向对象(OOP)

一 面向过程

面向过程思想：

1. 步骤清晰简单，第一步做什么，第二步做什么。。。
2. 面向过程适合处理一些简单的问题

二 面向对象

面向对象思想：

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

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

三 什么是面向对象

面向对象编程(Object-Oriented Programming,OOP)

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

让代码抽象化

三大特性：

1. 封装
2. 继承
3. 多态

从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。

从代码运行角度考虑是仙游类后有对象。类是对象的模板。

四 类与对象的关系

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

动物类，植物类，手机类，电脑类等等，这些类都是用来描述/定义某一类事物应该具有的特征和行为

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

五 创建与初始化对象

使用new 关键字创建对象

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

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

1. 必须和类的名字相同
2. 必须没有返回类型，也不能写void

写一个Dog类

public class Dog {
  //属性(字段)  
  int age;
  //方法(行为)
  public void run(){
    System.out.println("我"+age+"岁了run....");
  }
}

实例化两个Dog对象

public class Test {
  public static void main(String[] args) {
    Dog dog1 = new Dog();
    dog1.age = 2;
    dog1.run();//我2岁了run....
    Dog dog2 = new Dog();
    dog2.age = 3;
    dog2.run();//我3岁了run....
  }


}

六 构造器

一个类即使什么都不写，它也会存在一个方法，这个方法就是构造方法

public class Dog {

  int age;
  //空参构造方法，就算你不写，他也会默认存在，
  public Dog(){

  }

  public void run(){
    System.out.println("我"+age+"岁了run....");
  }
}

有参构造

public class Dog {

  int age;
  //空参构造方法，就算你不写，他也会默认存在，
  public Dog(){

  }
  //写了构造方法会使默认的空参构造失效，如果你还想用空参构造，就显示的把它写出来
  public Dog(int age){
    //this关键字指向本类
    this.age = age;
  }

  public void run(){
    System.out.println("我"+age+"岁了run....");
  }
}

实例化一个Dog对象

public class Test {
  public static void main(String[] args) {
    Dog dog = new Dog(1);
    dog.run();//我1岁了run....
  }
}

构造方法也可以重载

七 封装

隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别；将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。

记住这句话：属性私有化，提供set/get方法

访问修饰符

名称	当前类	同一包中	子类	所有
public	√	√	√	√
protected	√	√	√	×
default	√	√	×	×
private	√	×	×	×

写一个Dog类，并私有化属性

public class Dog {
  //属性私有化，在外部用对象名.属性名访问不到
  private int age;
  
  public void run(){
    System.out.println("我"+age+"岁了");
  }
}

提供set和get方法

public class Dog {
  private int age;

  public void run(){
    System.out.println("我"+age+"岁了");
  }
//get方法
  public int getAge() {
    return age;
  }
//set方法
  public void setAge(int age) {
     //加入控制，防止程序被破坏
    if (age > 0 && age < 50) {
        this.age = age;
    } else {
        this.age = 3;
    }
    
  }
}

外部可以用set或get方法操作属性

public class Test {
  public static void main(String[] args) {
    Dog dog = new Dog();
    dog.setAge(100);//不合法的
    dog.run();//我3岁了
  }
}

八 继承

继承，用关键字extends实现

extends的意思是扩展，子类是父类的扩展

java中只有单继承，一个孩子只有一个父亲，一个父亲可以有多个孩子

继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖，组合，聚合等。

继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类，使用关键字extends实现

编写一个Animal类

public class Animal {
  private String name;
  
  public void run(){
    System.out.println("动物跑");
  }
}

编写一个Dog类继承Animal类

public class Dog extends Animal{
  
}

子类对象可以使用父类对象的方法或属性（private修饰的方法或属性除外，如果是default，则要在同一包中）

final修饰的方法或属性不能被继承

public class Test {
  public static void main(String[] args) {
    Dog dog = new Dog();
    dog.run();//动物跑
  }
}

所有类都直接或间接继承Object类

私有的属性或方法无法被继承

final修饰的类无法被继承

super关键字

1. super关键字用于指向父类的属性

Animal类

public class Animal {
  protected String name = "动物";

  void run(){
    System.out.println("动物跑");
  }
}

Dog类

public class Dog extends Animal {
  private String name = "二哈";
  public void test(){
    System.out.println(name);//二哈
    System.out.println(this.name);//指向本类，二哈
    System.out.println(super.name);//指向父类的属性，动物
  }
}

2. super关键字用于指向父类的方法

Animal类

public class Animal {
  public void run(){
    System.out.println("动物跑");
  }
}

Dog类

public class Dog extends Animal {
  public void run(){
    System.out.println("二哈跑");
  }
  public void test(){
    run();//二哈跑
    this.run();//二哈跑
    super.run();//动物跑
  }
}

3. super关键字用于指向父类的构造方法

Animal类

public class Animal {
  
}

Dog类

public class Dog extends Animal {
  private String name;

  public Dog(){
    //如果不显示使用super(),它会默认有super()
    this.name = "二哈";
  }

  public Dog(String name){
    //调用本类的空参构造方法
    //this();
    //调用父类的空参构造方法
    super();
  }

}

super注意点：

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

new对象流程：

父类静态代码块（如果有）----》子类静态代码块（如果有）----》父类静态方法（如果有调用）-----》父类构造方法-----》子类静态方法（如果有调用）-----》子类构造方法

People类

public class People {

  public People(){
    System.out.println("父类构造方法");
  }
  static {
    System.out.println("父类静态代码块");

  }
  public static int run(){
    System.out.println("父类静态方法");
    return 1;
  }
  int a = run();
}

Student类

public class Student extends People{
  int b = run1();
  public Student(){
    System.out.println("子类构造方法");
  }
  static {
    System.out.println("子类静态代码块");

  }

  public static int run1(){
    System.out.println("子类静态方法");
    return 1;
  }
}

测试

public class Test {
  public static void main(String[] args) {
    Student student = new Student();
  }
}
/*
父类静态代码块
子类静态代码块
父类静态方法
父类构造方法
子类静态方法
子类构造方法
*/

九 方法的重写

方法的重写是指具有继承关系的两个类中，子类对象对父类对象方法的扩展或更改

Animal类

public class Animal {
  public void run(){
    System.out.println("动物跑");
  }
}

Dog类

public class Dog extends Animal {
  public void run(){
    super.run();
    System.out.println("二哈跑");
  }
}

测试

public class Test {
  public static void main(String[] args) {
    Dog dog = new Dog();
    dog.run();
  }
}
/*
动物跑
二哈跑
*/

注意点：

1. 需要有继承关系，子类对象重写父类对象的方法
2. 方法名必须相同
3. 参数列表必须相同
4. 返回值必须相同
5. 修饰符：范围可以扩大，但不能缩小
6. 抛出的异常，范围可以缩小，但不能扩大
7. static修饰的方法不能被重写

十 多态

同一方法可以根据发送对象的不同而采用不同的行为方式

一个对象的实际类型时确定的，但可以指向该对象的引用类型有很多

多态存在的条件：

1. 有继承关系
2. 子类重写父类方法
3. 父类引用指向子类

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

Animal类

public class Animal {
  public void run(){
    System.out.println("动物跑");
  }
}

Dog类

public class Dog extends Animal {
  public void run(){
    System.out.println("二哈跑");
  }
}

Cat类

public class Cat extends Animal {
  public void run(){
    System.out.println("Tom跑");
  }
}

测试

public class Test {
  public static void main(String[] args) {
    Dog dog = new Dog();
    run(dog);//二哈跑
    Cat cat = new Cat();
    run(cat);//Tom跑
  }
  public static void run(Animal animal){//形式参数类型是Animal，可以根据传过来的实际参数类型采取不同的行为
    animal.run();
  }
}

对象能执行哪些方法主要看对象左边的类型，和右边的类型无关

父类引用可以指向子类对象（向下转型），子类引用不可以指向父类对象，需要强转（向上转型）。通俗来讲，我要一个动物，你给我new了一个狗是可以的；但我要一个狗，你给我new一个动物就不行了。但可以把动物强转为狗

子类转为父类会丢失子类自己独有的方法

Animal dog1 = new Dog();
Dog dog2 = (Dog) new Animal();

instanceof关键字

instanceof关键字用于判断一个对象是否是什么类型

Dog dog = new Dog();
System.out.println(dog instanceof Animal);//true

instanceof关键字只能用在两个有关系的对象和类中，否则会报错

static关键字

static修饰属性，静态属性，属于类，不属于对象，所有该类的实例对象都可以访问，只初始化一次，可以用类名.属性名进行访问（属性不能私有化）

public class Dog extends Animal {
  public static String country = "中国";
  private String name;
  public Dog(String name){
    this.name = name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public String getName() {
    return name;
  }
}

测试

public class Test {
  public static void main(String[] args) {
    Dog dog1 = new Dog("二哈");
    System.out.println(Dog.country+dog1.getName());//中国二哈
    Dog dog2 = new Dog("金毛");
    System.out.println(Dog.country+dog2.getName());//中国金毛
  }

}

static修饰方法，该方法属于类，可以直接用类名.方法名进行调用

public class Cat{
  public static void run(){
    System.out.println("Tom跑");
  }
}

测试

public class Test {
  public static void main(String[] args) {
    Cat.run();//Tom跑
  }

}

static代码块，实例化对象时会被调用，只会执行一次

public class Cat{
  static {
    System.out.println("Tom出生了");
  }
}

测试

public class Test {
  public static void main(String[] args) {
    Cat cat1 = new Cat();//只输出一次 Tom出生了
    Cat cat2 = new Cat();
  }

}

static静态导入包

import static java.lang.Math.random;//可以直接导入该类中的方法
public class Test {
  public static void main(String[] args) {
    System.out.println(random());
  }

}

final关键字

1. final关键字修饰的方法不能被重写
2. final关键字修饰的变量是常量
3. final修饰的类不能被继承

十一 抽象类

abstract关键字可以用来修饰方法，也可以用来修饰类，如果修饰方法，那么该方法就是抽象方法，如果修饰类，那么该类就是抽象类

抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类

抽象类不能被实例化，它是用来让子类继承的

抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的

子类继承抽象类，那么就必须实现抽象类的所有抽象方法，否则该子类也要声明为抽象类

Animal类

public abstract class Animal {
  public void run(){
    System.out.println("run");
  }
  public  abstract void fly();
}

Cat类

public class Cat extends Animal{
  //需要实现fly()方法
  @Override
  public void fly() {
    System.out.println("fly");
  }
}

抽象类虽然不能new对象，但是它存在构造方法

十二 接口

普通类：只有具体实现

抽象类：具体实现和规范（抽象方法）

接口：只有规范（抽象方法）

接口就是规范，定义的是一组规则，体现了现实世界中，“如果你是。。。则必须能。。。”的想法。如果你是鸟，那你必须能飞

面向对象的精髓就是对对象的抽象，最能体现这一点的就是接口

一个类可以实现多个接口

接口用interface关键字表示

接中的方法都是抽象方法，接口中的变量都是常量

Animal类

public class Animal {
 
}

Moveable接口

public interface Moveable {
  //接口中的方法默认都是public abstract修饰的，可以省略不写，也建议省略不写
  public abstract void run();
}

Flyable接口

public interface Flyable {
  void fly();
}

Bird类

public class Bird extends Animal implements Moveable,Flyable {
  //实现Flyable接口中的方法
  @Override
  public void fly() {
    System.out.println("fly");
  }
  //实现Moveable接口中的方法
  @Override
  public void run() {
    System.out.println("run");
  }
}

接口的作用：

1. 制定一些约束和规范
2. 定义一些方法，让不同的人实现
3. 接口不能被实例化，接口中没有构造方法

十三 内部类

成员内部类

声明在一个类内部的类，内部类可以访问外部类的私有属性

public class Outer {
  private int a;
  
  public class Inner{
    public void test(){
      System.out.println(a);
    }
  }
}

实例化成员内部类

Outer.Inner inner = new Outer().new Inner();

静态内部类

声明在一个类内部并且被static修饰的类

public class Outer {
  private static int a;

  public static class Inner{
    public void test(){
      System.out.println(a);//静态内部类要想访问外部类的私有属性，那么该属性必须为static的
    }
  }
}

实例化静态内部类

 Outer.Inner inner = new Outer.Inner();

局部内部类

声明在方法中的类

public class Outer {
  private int a;
  public void test(){
    class Inner{
      
    }
  }
}

匿名内部类

没有类名的类

Animal类

public class Animal {
  public void run(){
    System.out.println("动物跑");
  }
}

测试

public class Test {
  public static void main(String[] args) {
    new Animal(){//用匿名内部类重写run()方法
      @Override
      public void run() {
        System.out.println("二哈跑");
      }
    }.run();
  }
}

匿名内部类是实现了一个借口或继承了一个抽象类

Flyable接口

public interface Flyable {
  void fly();
}

测试

public class Test {
  public static void main(String[] args) {
    Flyable flyable = new Flyable() {
      @Override
      public void fly() {
        System.out.println("fly");
      }
    };
  }
}

Animal抽象类

public abstract class Animal {
  public abstract void run();
}

测试

public class Test {
  public static void main(String[] args) {
    Animal animal = new Animal() {
      @Override
      public void run() {
        System.out.println("run");
      }
    };
  }
}