从零开始的Java之路（6）–面向对象（oop）

面向对象编程（oop）

本质：以类的方式组织代码，以对象的形式组织（封装）数据

三大特性：

• 封装
• 继承
• 多态

对象是具体的事务。类是对对象的抽象，类是对象的模板。

创建与初始化对象

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

注：一个项目应该只能存在一个main方法

public class Person {
    //类即使什么也不写也会存在默认无参构造函数
    String name;

    public Person(String name) {
        this.name = name;
    }
    //new本质是在调用构造方法
    //定义有参的构造方法后要想使用无参的构造方法必须显式定义
    public Person() {
    }
}

引用类型：基本类型（8）

对象是通过引用来操作的：栈—>堆

默认初始化：

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

封装

程序设计追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用

封装：数据的隐藏，属性应该私有

好处：

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

继承

本质是对某一批类的抽象，从而实现对现实世界更好的建模

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

Java中只有单继承没有多继承

类与类之间的关系还有依赖，组合，聚合等

子类继承了父类，就会拥有父类的public和protected的属性和方法

object类

Java中所有的类都默认间接或直接地继承object类

super关键字

public class Student extends Person {
private String name="xiaoyu";

    public Student() {
        //隐藏代码，调用了父类的无参构造
        //调用父类的构造器必须要在子类构造器的第一行
        super();
        System.out.println("子类构造");
    }

    public void test(String name){
    //this调用当前类的对象的属性或方法
    //super调用父类的属性或方法
    System.out.println(name);
    System.out.println(this.name);
    System.out.println(super.name);
}
}

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

重写

需要继承关系，子类重写父类的方法！（类似于c++中的虚函数）

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大：public>protected>default>private
4. 抛出异常：范围可以缩小但不能扩大

重写，子类的方法名和父类必须要一致，方法体不同

为什么要重写：

1. 父类的功能，子类不一定需要，或者不一定满足！

public class Application {
    //静态方法：方法的调用只和左边，定义的数据类型有关
    //非静态方法：可以重写
    public static void main(String[] args) {
        A a=new A();
        a.override();
        //父类的引用指向了子类
        B b=new A();//子类重写了父类的方法
        b.test();
        a.override();
        b.override();
    }
}

public class B {
    public static void test(){
        System.out.println("b.test");
    }
    public void override(){
        System.out.println("b.override");
    }

}

public class A extends B {
    public static void test(){
        System.out.println("a.test");
    }

    @Override//重写
    public void override() {
        System.out.println("a.override");
    }
}

多态

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

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

存在条件：继承关系，方法需要重写，父类的引用指向子类对象

一个对象的实际类型是确定的，但指向的引用类型可以不确定：父类的引用指向子类

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

A a=new A();
B b=new A();
//子类可以调用自己或继承自父类的方法
//父类型可以指向子类，但不能调用子类独有的方法

注：不能实现多态的情况

1. static 方法，属于类，不属于实例
2. final 常量
3. private 方法

instanceof (类型转换) 引用类型转换

instanceof (类型转换)

public class Application {
    //静态方法：方法的调用只和左边，定义的数据类型有关
    //非静态方法：可以重写
    public static void main(String[] args) {
        A a=new A();
//        a.override();
        //父类的引用指向了子类
        B b=new A();//子类重写了父类的方法,子类转换为父类，可能丢失自己的本来的一些方法
//        b.test();
//        a.override();
//        b.override();
        Object object=new A();
        //判断对象的类型是否相似于指定类型
        System.out.println(object instanceof A);
        System.out.println(object instanceof B);
        System.out.println(object instanceof Object);
        System.out.println(object instanceof String);
        //强制类型转换
        ((A) b).go();
    }
}
/*
1.父类引用指向子类的对象
2.把子类转换为父类，向上转型
3.把父类转换为子类，向下转型，强制转换
4.方便方法的调用，减少重复的代码
 */

static

静态变量

静态方法

静态代码块

静态导入包

注：final修饰的类不能被继承

//静态导入包~ 
import static java.lang.Math.random;
public class Person {
    public Person(){
        System.out.println("构造方法");
    }
    //代码块先执行，静态代码块最先执行
    {//匿名代码块，创建一次对象执行一次，可用于为对象赋初始值
        System.out.println("default");
    }
    static{//静态代码块，只执行一次
        System.out.println("static");
    }


    public static void main(String[] args) {
        System.out.println(random());
        Person person1=new Person();
        System.out.println("===========================");
        Person person2=new Person();
    }

}

抽象类

用abstract可以修饰类和方法

可以定义构造方法

//abstract 抽象方法
//类只能单继承，接口可以多继承
public abstract class Action {
    //抽象方法只有方法的名字没有方法的实现
    public abstract void doSomething();
    //1.不能new，只能靠子类来实现
    //2.抽象类可以赐额普通方法，抽象方法只能写在抽象类里
}

//抽象类的所有方法，继承了他的子类，必须重写他的方法，除非子类也是抽象类
public class A extends Action {
    @Override
    public void doSomething() {

    }
}

接口

类：只有具体实现

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

接口：只有规范

//接口时oop的精髓
//用interface 定义关键字,接口都需要有实现类
//接口不能被实例化，接口没有构造方法
public interface UserService {
    //接口中所有的定义其实都是抽象的 都是public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void quary(String name);
    //接口默认定义常量，一般不定义常量
}

public interface TimeService {
}

//抽象类extends
//接口 implements
//实现接口的类必须要重写接口中的方法
//类可以多继承接口
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 quary(String name) {

    }
}

内部类

package com.zhang.oop.demo4;
public class Outer {
    private static int ID=10;
    private int id=10;
    public void out(){
        System.out.println("Outer");
    }
    public class inner{
        public void in(){
            System.out.println("Inner");
        }

    }
    public static class Inner{

        //可以获得外部类的私有属性

        public void getID(){
            System.out.println(ID);
        }
        //局部内部类
        public void method(){
            class inner{
                public void in(){

                }
            }
        }


    }
}
//一个Java类中可以有多个class类，但只能有一个public class
class X{

}


package com.zhang.oop.demo4;
public class Application {
    public static void main(String[] args) {
        Outer outer=new Outer();
        Outer.inner inner=outer.new inner();
        inner.in();
        outer.out();
    }
}

package com.zhang.oop.demo4;
//没有名字初始化类，不用将实例保存到变量中~
public class Test {
    public static void main(String[] args) {
        new Apple().eat();
        UserService1 userService1=new UserService1() {
            @Override
            public void hello() {

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

interface UserService1{
    void hello();
}