面向对象

面向对象

​ 利用 物以类聚、分类的思维模式。 对分类进行单独思考、再细化（面向过程->线性思维）。

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

方法回顾和加深

​ 回顾的简单案例：

/**
     * 修饰符 返回值类型 方法名(...){
     *     //方法体
     *     return 返回值;
     * }
     */
    public int max(int i,int j){
        return i>j ? i : j;
    }

Student类

public class Student {

    public void show(){
        System.out.println("I am Studnet");
    }
}

实例化对象

对象类型 对象名 = 对象值

eg：

public static void main(String[] args) {
        //对象类型 对象名 = 对象值
        Student student = new Student();
    }

调用对象的相关方法

对象名.对象方法 ()

eg:

student.show();//I am Studnet

注：

​ 1.静态方法可使用非静态方法、但非静态方法不可调用静态方法

​ 【静态方法会直接生成、而非静态方法只有类实例化后才生成】

​ 2.基本类型做形参时为值传递、引用类型做形参时为引用传递

对象的创建

​ 对象只拥有 属性 和 方法

public class Student {

    //属性：字段
    String name;
    int age;

    //方法
    public void show(){
        System.out.println("I am Studnet");
    }
}

​ 创建对象和调用相关数据

​ 每一个new的对象都是单独的分配区间，即实例化后的对象是不同的

//main方法
    public static void main(String[] args) {
        Student Tom = new Student();
        Student Jerry = new Student();

        Tom.name="Tom";
        Jerry.name="Jerry";

        System.out.println(Tom.name); //Tom
        System.out.println(Jerry.name); //Jerry
    }

构造器

​ 用于初始化类

​ 注：

​ 构造器必须和类名相同

​ 没有返回值

所以当new实例化对象时，本质就是在调用构造器

Student类 （带构造器）

public class Student {

    //属性：字段
    String name;
    int age;

    //无参构造
    public Student(){

    }

    //有参构造、可对数据进行一定的加工处理
    public Student(String str,int num){
        this.name=str; //this.xxx  表示当前对象的xxx
        this.age = num;
    }
}

​

面向对象三大特性

封装

​ 高内聚、低耦合 =>类的内部数据操作由程序员万层，不允许外部干涉。仅暴露一小部分内容给外部使用

​ 通常采用 private 来表明私有

​ 这些内容 属性，get,set 应当都私有

eg: Student 封装样式

public class Student {

    //属性：字段
    private String name;
    private int age;

    private void show(){
        System.out.println("I am student");
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

作用：

​ 提高安全性，保护数据

​ 隐藏代码实现细节

​ 统一接口

​ 增加可维护性

继承

​ 对某一批类的抽象

​ 继承后，子类和父类之间 具有 xxx" is a "xxx 的关系

注：

​ Java 只有 单继承 !!!

语法形式：

class 子类 extends 父类

特点：

​ 子类可拥有父类的所有属性、方法

​ Object 类 是 所有类的父类

​

eg：

//父类 人
class Person{
    String name;

}

//子类 教师类
class  Teacher extends Person{

}


//子类 学生类
class Student extends Person{


    public void show(){
        System.out.println(this.name);
    }
}

其中 父类的相关内容 由 修饰符来表明 权限

​ public > protected > default > private [不被子类所继承]

super 关键字

​ super 通常用于 子类 调用 父类 内容。

注：

​ 构方都会默认super()，即调用父类的无参构造。

​ 其中 若要super()必须是第一行

class Student extends Person{
    private String name = "Z";

    public void show(String name){
        System.out.println(name); //name
        System.out.println(this.name); // Z
        System.out.println(super.name); //F
    }
}

方法重写

​ 子类继承父类后，对父类方法的重新设计

​

​ 注：

​ 方法名相同

​ 参数列表相同

​ 修饰符可以扩大

​ 异常可被缩小

//Test类
public class Test {

    //main方法
    public static void main(String[] args) {

        Person p =new Person();
        Student s = new Student();

        p.show();
        s.show();



    }


}

//父类 人
class Person{

    public void show(){
        System.out.println("Person");
    }

}


//子类 学生类
class Student extends Person{

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

多态

​ 父类的引用指向子类

​ 用于动态编译、增加 可拓展性

语法形式：

父类 对象名 = new 子类();

注：

​ 父类指向子类时，不可调用子类独有的方法

​ 子类可调用本身或父类的方法

相关关键字

​ instanceof 判断是否为是否有继承关系，即是否相似。 以便于后续的类型转换

​ 子类转换父类，向上转型。

​ 父类强转子类，会丢失一些方法。向下转型。

抽象类

​ abstract 修饰符来修饰。

​ 修饰方法则方法->抽象方法，修饰类->抽象类

​ 注：

​ 抽象类，不可被new实例化对象，仅可被子类继承

​ 抽象方法，只有声明，没有方法实现，仅可被子类实现。

​

​ 子类继承抽象类后，必须实现相关抽象方法，否则需要声明为抽象类

//abstract 抽象类
abstract class AbstractClass{

    //约束方法规范 -> 交予子类实现
    public abstract void doSomething();
}


class AbstractImpl extends AbstractClass{

    //必须实现相关抽象方法
    @Override
    public void doSomething() {

    }
}

接口

​ 接口就是一组规范。

定义接口的形式

interface xxx{}

类 实现接口的形式：

class xxx implements xxx,xxx,xxx{}

注：

​ 接口中的所有定义 都默认带 public abstract

​ 接口可被多实现、即 一个类可以实现多个接口

​ 接口不可被实例化

interface InterfaceDemo{

    //接口中的所有定义 都默认带 public abstract
    void run();
    
    int max(int i,int j);
}

class InterfaceImpl implements InterfaceDemo{
    
    public void run(){
        System.out.println("run....");
    }

    @Override
    public int max(int i, int j) {
        return i>j?i:j;
    }
}

内部类

​ 在一个类的内部再定义一个类。

成员内部类

class Outer{

    private int id=1;
    public void outershow(){
        System.out.println("这是外部类的方法");
    }

    public class Inner{

        public void innershow(){
            System.out.println("这是内部类的方法");
        }

        /*
            内部类访问外部类的私有内容
         */
        public  void getOuterId(){
            System.out.println(id);
        }
    }
}

public class Test {

    //main方法
    public static void main(String[] args) {

        Outer outer = new Outer();

        //通过外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();

        inner.innershow(); //这是内部类的方法

        inner.getOuterId(); // 1

    }

}

静态内部类

当static后 就不可访问外部内的相关内容

class Outer{

    private int id=1;
    public void outershow(){
        System.out.println("这是外部类的方法");
    }

    public static class Inner{

        public void innershow(){
            System.out.println("这是内部类的方法");
        }
    }
}

局部内部类

​ 一个java中，可以有多个class类，但仅有一个public class类

​ 该类既可以存于类中，又可以存在于方法这个，但作用域仅作用于当前。

匿名内部类

​ 实例化类时，可以不赋予一次。

​ 但该实例化类仅进行一次，不可进行后续的操作。

public class Test {

    //main方法
    public static void main(String[] args) {

        new NoName().show(); // 我可以没有名字

    }


}

class NoName{

    public void show(){
        System.out.println("我可以没有名字");
    }
}