JAVA07-面向对象_static 方法同一package才可用-CSDN博客

本文链接：https://blog.csdn.net/maxkd/article/details/117188567

面向对象

1. 什么是面向对象

以类的方式封装代码，以对象的方式封装数据
三大特性：
- 封装
  
  把一些代码封装成一个模块，提供一个出口供调用
- 继承
  
  A类继承B类，A就拥有了B的所有性质
- 多态
  
  一个类可以有多种不一样的对象
类和对象的关系：类是对象的模版

2. 方法的调用

静态方法：有static进行标记，可以在同一package内直接调用该类的方法
```
Student.say();                     //直接调用
```

非静态方法：

Student student = new Student();   //实例化
student.say();                     //先实例化再调用

关于static：static方法和类一起存在，而非static方法只有当实例化之后才存在，所以两个方法都有static或都没有static时可以互相调用；而一个有static一个没有static就不能互相调用。

Java里面都是值传递，但如果传递的是一个实例化的类对象，则是引用传递

3. 类与对象的创建

使用关键字new创建对象：会进行默认的初始化，

一个项目一个只存在一个main方法，在整个项目只定义一个main
- 属性
- 方法
使用this指定使用的变量是该类内定义的属性，以此来调用

4. 构造器

一个类即使什么都不写，也会默认生成一个与类名同名的构造器（构造方法）

右上角齿轮–>-->Project Structure–>Module–>add Content Root–>out文件夹（可以看见class文件）

作用：
- 初始化属性值
  
  使用this.
- 定义了有参构造，在new的时候想使用无参构造，就必须显式地定义无参构造器
- 如果有传值则自动调用有参构造，若没传值则自动调用无参构造
注意不要用static去定义构造器，不然在编译阶段就会使使用了static的构造器被创建

5. 封装

public：公有
private：私有
protected:

类内的属性一般私有，不允许外部进行调用，而用公有的方法去设置它
意义：
- 提高程序的安全性
- 隐藏代码的实现细节
- 统一了接口
- 提高了系统的可维护性

6. 继承

关键字：extends
```
public class Student extends People{
    //
}
```
Student 继承了People的所有方法和属性，子类是父类的拓展和延伸（只限定于public, 对于private,子类不能调用继承的）
在Java中类都直接或间接继承了Object类
super.：用于调用父类的属性和方法（private不行）

使用构造器时，会先默认隐藏调用父类的构造器，所以在无参构造器使用super()时，必须把super()放在最上面

方法的重写

定义了A类和B类并让A继承B

public class Main {
    public static void main(String[] args) {

        A a = new A();
        a.test();

        B b = new A();
        b.test();
    }
}

//AClass
public class A extends B{
    public void test(){
        System.out.println("Atest");
    }
}

//BClass
public class B {
    public void test(){
        System.out.println("Btest");
    }
}

此时的输出结果为：

Atest
Atest

看另一种情况：

public class Main {
    public static void main(String[] args) {

        A a = new A();
        a.test();

        B b = new A();
        b.test();
    }
}

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

//BClass
public static class B {
    public void test(){
        System.out.println("Btest");
    }
}

此时的输出：

Atest
Btest

区别：

静态方法是类的方法，非静态方法是对象的方法
没有static时，b调用的是对象的方法，因为b是A new出来的
有static时，b调用的是B类的方法，因为b是B类定义的

父类的引用指向了子类：子类重写了父类的方法

重写的要求：

子类和父类方法名要一致
参数列表要一致
修饰符只能扩大不能扩缩小：public>protected>default>private
抛出的异常范围只能缩小

7. 多态

同一个方法，不同对象去调用产生的效果不同

多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：
在这里插入图片描述

现实中，比如我们按下 F1 键这个动作：

如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；
如果当前在 Word 下弹出的就是 Word 帮助；
在 Windows 下弹出的就是 Windows 帮助和支持。

同一个事件发生在不同的对象上会产生不同的结果。

多态存在的条件：
- 继承
- 重写
- 父类引用指向子类对象：Parent p = new Child();
使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
instanceof:存在父子关系就返回ture,否则返回false
子类可以自动转换为父类，而父类要强制转换为子类
指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性，而对于子类中存在而父类中不存在的方法，该引用是不能使用的，尽管是重载该方法。若子类重写了父类中的某些方法，在调用该些方法的时候，必定是使用子类中定义的这些方法（动态连接、动态调用）。跳到多态的解释

8. static

static：如果有static前缀则可以直接用类调用其中的static方法和static属性；如果没有，则要先实例化对象，通过对象去调用

9. 抽象类

abstract:抽象方法，只有方法的名字，没有方法的实现

public abstract void Action(){
    public abstract void doSomething();   //子类去实现
};

抽象类不能被new出来!

类内有抽象方法，则类必须被定义为抽象类；如果类是抽象类，则类内可以定义普通方法

作用：

其实不是说抽象类有什么用，一般类确实也能满足应用，但是现实中确实有些父类中的方法确实没有必要写，因为各个子类中的这个方法肯定会有不同，所以没有必要再父类里写。当然你也可以把抽象类都写成非抽象类，但是这样没有必要。

而写成抽象类，这样别人看到你的代码，或你看到别人的代码，你就会注意抽象方法，而知道这个方法是在子类中实现的，所以，有个提示作用。

10 . 接口

定义：interface
作用：只有声明没有实现，规范化
默认：在interface内定义默认是public abstract方法

实现：implments，接口都需要实现类后缀Impl，例如myClassImpl

public interface MyServiceClass {
    //定义的属性默认是常量 public abstract final
    int AGE = 10;
    //默认是public abstract
    void add(int num);
    void delete(int num);
    void change(int num);
    void search(int num);
}

//另一个Class,实现必须重写接口方法
public class MyServiceClassImpl implements MyServiceClass{
    @override
    void add(int num){
        //
    }
    @override
    void delete(int num){
        //
    }
    @override
    void change(int num){
        //
    }
    @override
    void search(int num){
        //
    }
}