封装继承多态，static 等关键字内部类等Java面向对象知识细节，快速了解

面向对象

面向过程：一步一步的进行。

面向对象：物以类聚，分类思想，思考问题，拆分问题，组合问题。

对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要面对象的思路来分析整个系统，但是具体的细节操作还是面向过程。

面向对象的本质是：以类的方式组织代码，以对象的方式组织数据

三大特征：封装，继承，多态,见下文详细解释

1. 封装：将数据，对象，方法根据不同的私密层度进行组织
2. 继承：在一个丰富的父类方法中，继承他的一些方法。
3. 多态：调用同一个方法，不同的对象会出现不同的结果和作用。

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

一个类只应该有属性和方法

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

属性 方法

return：终止方法，返回一个结果。后面的语句不会执行且报错。

方法的调用：

静态方法修饰**：static 用static 修饰了的方法，在同一个包下的其它类可以直接调用（类名.方法（））无需无需实例化,如果不在同一个包内只需要import导入，是和类一起加载的，所以会同时存在，而没有被static修饰的，类实例化后才存在。

package com.pan.scaner;

public class Student {
    //在student里定义一个say方法
    public static void say(){
        System.out.println("你好老师");
    }
}

package com.pan.scaner;

public class Demo04 {
    public static void main(String[] args) {
        //由于student类里的say()方法是由static修饰，所以可以直接调用
        Student.say();
        //若没有static
        new Student().say();
    }
}

构造器：是在进行创建对象时必须要调用的，有以下特点，

作用：使得new 创建对象能正常创建

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

属性 方法

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

构造器的使用：

实例化初始值时调用无参构造，使用new 关键字必须调用构造器，

无参构造器会自动生成加载，可不被定义

有参构造一旦被定义，无参构造就必须显示定义，有参构造也称重载

**封装：**高内聚，低耦合

属性私有化，再利用get/set方法或者其他接口调出

get:

set:

package com.pan.scaner;

public class Demo05 {
    private String bookName;
    private int page;
    private String author;

    //获取bookName
    public String getBookName(){
        return bookName;
    }
    //设置bookName
    public void setBookName(String bookName){
        this.bookName = bookName;
    }
}

package com.pan.scaner;

public class Demo04 {
    //会自动创建构造器
    public static void main(String[] args) {
        Demo05 demo05 = new Demo05();
        demo05.setBookName("java程序设计");
        System.out.println(demo05.getBookName());
    }
}

继承

一个类继承一个类：继承者为子类，被继承者为父类，对一批类的抽象和联系起来。

关键词：A extend B A继承B

继承特点：

• 子类会继承所有父类的公有方法
• 所有的类都会默认继承Object
• super调用父类的构造方法，super必须只能出现在子类方法后构造方法中且在第一行，this和super不能同时出现在调用构造方法中
• 方法重写方法名相同，参数列表相同，，只有方法体不同，修饰符，抛出异常范围不可以扩大（父 public —> 子private），重写是因为父类的方法不一定全部需要，或者全部满足（alter+ insert）

package com.pan.scaner;

public class ExtendsA{
    public static void main(String [] agrs){
        B b= new B();
        b.test1();
        
        //父类的引用指向子类
        A a = new B();
        a.methond();
    }
}
class A{
    private String dates = "昨天";
    
    public void methond(String dates){
        System.out.println(dates);
        //this 调用A类的dates"昨天"
        System.out.println(this.dates);
        //System.out.println(super.dates);
    }
    public String getDates(){
        return dates;
    }
    public void setDates(String dates){
        this.dates = dates;
    }
}

class B extends A{
    public void test1(){
        //super 调用A类的methond(String dates) 方法
        super.methond("今天");
    }
}

多态

• 多态是方法的动态编译，不同对象调用同一个方法，会有不同的编译结果
• 要是继承关系， 方法需要重写，父类引用指向子类对象（static 方法不能重写，属于类方法同步加载，不属于实例）

package com.pan.scaner;

public class Student {

    public static void main(String[] args) {
        //父类的引用指向子类，但不能调用子类的独有方法
        pan  b1 = new Book();
        b1.say();
        //强制转换,b1 pan转换为Book,有高转换为低
        ((Book) b1).test();

        pan p1 = new pan();
        p1.say();
    }
}
class pan {
    //父类的say()方法
    public void say() {
        System.out.println("pan 的方法");
    }
}
class Book extends pan{
    //重写父类发的方法
    @Override
    public void say() {
        System.out.println("在book 中重写pan的方法");
    }
    //子类的新方法
    public void test(){
        System.out.println("book 的新方法");
    }
}

重载的目的：功能类似的方法使用同你一个名字，更容易记住

重写的目的：子类重写父类的方法时，有些方法不用用到，还有些新方法要实现

重载和重写的区别

• 重写只改变方法体
• 重载不改变名字，改变参数数量类型，排序等
• 重写是继承关系，重载是在本类或其它类实现

static 关键字静态代码块细节理解

• 类修饰符，随着类一起加载，可以由类直接调用
• 静态代码块
• 静态导入包，导入了报的一些常量或方法，在代码中可以直接使用

package com.pan.scaner;
//静态导入包
import static java.lang.Math.random;
public class Demo06 {
    //静态代码块
    //首先执行
    {
        System.out.println("匿名类代码块");
    }
    //只执行一次，其次执行
    static{
        System.out.println("静态代码块");
    }
    //构造方法最后执行
    public Demo06(){
        System.out.println("构造方法");
    }
    
    public static void main(String[] args) {
        //原本是Math.random(),但直接用静态导入了
        System.out.println(random());
    }
}

final 修饰的类不能继承

**普通方法：**只有实现

抽象类：具体实现和规范都有

目的：做一个方法约束，命名方便管理

特点：只有方法的名字，没有具体得实现，需要子类帮他完成实现

抽象类中可以写普通方法，抽象方法必须在抽象类中。

存在构造器，子类继承父类后需通过父类的构造器来实例化。

public abstract class A{
    public abstract void do(){
        //可以在抽象方法中定义普通方法
        public void hello(){   
        }
    }
}

接口interfac

目的：只有规范，自己无法写方法，约束和实现分离，让不同的人实现。面向接口编程。

• 接口都需要实现类 implements
• 实现接口的类，就需要重写接口中的所有方法
• 侧面实现多继承
• 接口中定义常量都是静态常量

内部类

目的：提高内部代码的内聚，减少额外代码

在类的里面创建一个类

• 成员内部类
• 静态内部类,用static修饰即可，但要注意静态内部类访问静态属性
• 局部内部类，在方法内部创建的类
• 匿名内部类，用接口实现时创建的内部匿名类

package com.pan.scaner;

public class Demo07 {
    private int id ;
    public void outer(){
        System.out.println("这是外部类方法");
    }
    //创建一个内部类
    public class Inner{
        public void in(){
            System.out.println("这是内部类");
        }
    }
}
//这也算一个外部类，在整个类中，只能有一个public修饰的类
class Outer1{
    
}