面向对象

以类的方式组织代码，以对象的方式组织数据。

三大特性

• 封装
• 继承
• 多态

类

一个类中拥有成员变量、类构造器、类方法三部分组成。

• 类构造器是创建该类对象时所调用的方法，构造器总是先手调用父类的构造方法，再调用自身的。
• 除了构造器，其他的东西都需要对象去调用，除了static修饰的。
• 类加载的同时伴随着static修饰的变量、方法的加载
  • 加载时机
  • 1. 饿汉式：只要有其他类引用时加载
    2. 懒汉式：类初始化时加载 （即赋值）

对象

对象是一个类的实例，通常把类理解成模板，对象理解为按模板做出来的产物。

封装

• 隐藏成员变量和实现细节，不允许外部直接访问；

• 开放部分方法，通过方法控制成员变量；

权限修饰符

get与set

当成员变量为私有修饰符修饰时，一般给出该成员变量的set方法和get方法，这两个方法通常对外开放，使得外部可通过调用方法的方式访问该成员变量，是封装的常见手法。

继承

继承通过extends关键字完成，继承者拥有被继承者所有可被继承的方法、变量。

多态

对象句柄（对象引用）

该概念是声明的 类变量

 Student jzj = new Student();	//这里jzj被称为“对象句柄（对象引用）”

多态三要素

1. 继承关系
2. 子类重写父类方法
3. 子类对象的地址 赋值给 父类对象句柄

多态的常见使用

1. 方法的形参选用一系列子类共同的父类对象，目的节省重载代码量。
2. 方法的返回值选用父类类型，可返回该父类的子类对象。

转型

• 向上转型：子类对象的地址 赋值给 父类对象句柄

• 向下转型：父类句柄 强制转换后赋值给 子类句柄。

关键字instanceOf

a instanceOf b：判断a对象句柄是否为b对象句柄或是b的子类对象句柄。

package com.jzj.five;

public class TestOO {
    public static void main(String[] args) {
    	//Classroom是父类	Student是子类
        Classroom jzj = new Student();
        //通过父类对象句柄 调用 子类重写的方法
        jzj.getPrint();
    }
}

package com.jzj.five;

public class TestOO {
    public static void main(String[] args) {
        Student jzj = new Student();
        //引入子类句柄	返回值	使用父类句柄接收
        Classroom jzjClass = testMethod(jzj);
        //父类句柄调用方法	输出为：子类重写了的方法
        if(null != jzjClass)
      		jzjClass.getPrint();
    }
	//参数为父类句柄	，	返回值为父类句柄
    public static Classroom testMethod(Classroom c){
        //判断参数是否为Classroom类 或 其子类
        if(c instanceof Classroom)
            return c;
        return null;
    }
}

关键字static

• 变量
• 方法
• 代码块

static类

package com.jzj.five.usestatic;

public class staticInnerClass {
    public static class InnerClass{
        public InnerClass() {
            System.out.println("静态内部类");
        }
    }
}

package com.jzj.five.usestatic;

public class staticInnerClassTest {
    public static void main(String[] args) {
         //staticInnerClass类 直接调用 静态内部类成员
        new staticInnerClass.InnerClass();
       //输出“静态内部类”
    }
}

• static修饰类，类只能是内部类作为成员变量被修饰。

• 被static修饰的，都可以直接通过类名直接调用。

• static修饰的代码块，在类初始化时，早于构造器调用。

关键字final

• 变量
• 类
• 方法

final修饰类

final修饰类不可以被继承，可以继承其他类

final修饰变量

final修饰的变量称为常量，只能赋值一次。

final修饰方法

final修饰的方法，不可以被重写，但是可以继承使用。

package com.jzj.five.usefinal;

public class People {
    //常量id
    public final int id = 25;
    //不允许重写
    public final void eat(){
        System.out.println("吃");
    }
}

package com.jzj.five.usefinal;
//可继承其他类,其他类不可继承此类
public final class Student extends People{
    public static void main(String[] args) {
        Student jzj = new Student();
        //输出“吃”
        jzj.eat();
        //jzj.id = 26;      报错，因为id只能接受一次赋值
        //	报错，该方法不允许重写
        //    @Override
        //    public final void eat(){
        //        System.out.println("吃东西");
        //    }
    }
}

抽象类

关键字abstract

• 抽象类是子类的约束，一种规范。

• 抽象类在创建对象时，必须重写抽象方法。

• 抽象类可以有普通方法。

package com.jzj.five.useabstract;
//抽象类
public abstract class Action {
    //抽象方法，供继承者重写，是规范该类必须有的行为。
    //子类必须重写该抽象方法
    public abstract void run();
    public void eat(){
        System.out.println("eat");
    }
}

package com.jzj.five.useabstract;

public class ActionSon extends Action{
    public static void main(String[] args) {
        Action ac = new Action() {
            @Override
            public void run() {
                System.out.println("run");
            }
        };
        ac.run();
    }

    @Override
    public void run() {
        System.out.println("跑");
    }
}

接口

关键字interface

• 不允许有普通方法。

• 接口的存在是更纯粹的规范。

• 接口中所有方法默认为public abstract修饰的。

• 接口所有的成员字段都默认为public static final修饰的。

• 规范可以有多个实现类，实现类重写接口里面所有的方法。

• 支持多继承

• 一个实现类可以实现多个接口

package com.jzj.five.useinterface;

public interface StudentAction2 {
    void eat();
    void sleep();
}

package com.jzj.five.useinterface;
//接口继承接口
public interface StudentAction extends StudentAction2{
    void learn();
    void talk();
    void walk();
}

package com.jzj.five.useinterface;
//实现接口的类
public class Student implements StudentAction{

    public String name;

    public Student(String name) {
        this.name = name;
    }

    @Override
    public void learn() {
        System.out.println("learn");
    }

    @Override
    public void talk() {
        System.out.println("talk");
    }

    @Override
    public void walk() {
        System.out.println("walk");
    }

    @Override
    public void eat() {
        System.out.println("eat");
    }

    @Override
    public void sleep() {
        System.out.println("sleep");
    }
}

package com.jzj.five.useinterface;

public class interfaceTest {
    public static void main(String[] args) {
        StudentAction studentInterface = new Student("jzj");
        //报错，因为studentInterface是接口，接口中没有该成员变量name
        //studentInterface.name;  
        //但是接口，可以调用实现类的方法
        studentInterface.sleep();
    }
}

内部类

一个类中再定义一个类。

• 成员内部类 // 通过外部类对象调用，内部类对象引用。
• 静态内部类 //通过外部类直接调用该内部类对象引用。
• 局部内部类 //在方法中定义的类
• 匿名内部类 //作为内部类被匿名的调用

内部类可以调用外部类的私有字段

匿名内部类例子：

package com.jzj.five.useinnerclass;

class Test{
    public static abstract class InnerClass{
        abstract void sleep();
    };

    public static void useAnInner(InnerClass i){
        System.out.println("useAnInner");
        i.sleep();
    }

    public static void main(String[] args) {
        //匿名内部类的使用
        useAnInner(new Test.InnerClass() {
            @Override
            void sleep() {
                System.out.println("sleep");
            }
        });
        //输出useAnInner
        //输出sleep
    }
}

匿名类

匿名类指的是 创建的对象不给任何对象句柄赋值。

new Student().sleep(); //通过匿名类调用方法

JAVA-05-面向对象

原文：https://www.cnblogs.com/jzj-code/p/14307511.html