Vstar项目练手——学习笔记（2）

面对对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。

package com.company;
//引用传递：对象，本质还是值传递
//对象，内存
public class test05 {
    public static void main(String args[]){
        Person person = new Person();
        System.out.println(person.name);//null
        change(person);
        System.out.println(person.name);//牛马
    }

    public static void change (Person person){
        person.name ="牛马";
        //person是一个对象：指向的---》Person person = new person();这是一个具体的人，可以改变属性
    }
}
//定义了一个Person类，有一个属性：name
class Person{
    String name;//null
}

创建与初始化对象

一个类即使什么也没写，它也会 存在一个方法。（程序就是对世界建模）

/*
1.类与对象
    类是一个模板：抽象，对象是一个具体的实例
2.方法
    定义、调用
3.对象的引用
    引用类型： 基本类型（8）
    对象是通过引用来操作的：栈--->堆

4.属性：字段Field成员变量
    默认初始化：
    数字： 0   0.0
    char： u0000
    boolean:false
    引用：null

   修饰符 属性类型 属性名 = 属性值
5.对象的创建和使用
    - 必须使用new 关键字创建对象，构造器 Person xxx = new Person();
    - 对象的属性 xxx.name
    - 对象的方法 xxx.workout()
6.类
    静态的属性 属性
    动态的行为 方法


 */

封装的好处：

1.提高程序的安全性，保护数据

2.隐藏代码的实现细节

3.统一接口

4.系统可维护性增加了

更新于2022.4.24

/*
重写：需要有继承的关系，子类重写父类的方法！
    1.方法名必须相同
    2.参数列表必须相同
    3.修饰符：范围可以扩大但不能缩小：  public>Protected>Default>private
    4.抛出的异常：范围，可以被缩小，但不能扩大：  ClassNotFoundException --> Exception(大)
重写，子类的方法和父类必要一致；方法体不同

为什么要重写：
    1.父类的功能，子类不一定需要，或者不一定满足
    Alt+Insert ; override
 */
/*
多态注意事项：
1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系 类型转换异常 ！ClassCastException
3. 存在条件： 继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son();

无法重写的：
1. static 方法，属于类，它不属于实例
2. final 常量；
3. private方法；
 */

更新于2022.4.29

package com.company;

public class test06 {
    private static int age;//静态的变量 多线程！
    private double score;//非静态的变量

    public void run(){

    }

    public static void go(){

    }
    public static void main(String[] args){
        go();//这个可以直接使用
        run();//这就不行
        new test06().run();//要通过对象点方法才能使用
    }
}

package com.company;
public class test06{
    {
        //匿名代码块
        //第二个执行
        System.out.println("匿名代码块");
    }

    static{
        //静态代码块
        //最先执行
        System.out.println("静态代码块");
    }

    public test06(){
        //构造方法
        //第二个执行
        System.out.println("构造方法");

    }
    public static void main(String[] args){
       test06 test06 = new test06();
    }
}

静态代码只执行一次

（这里我们在new一次）

此处添加代码

抽象类笔记：

思考：1.抽象类中存在构造器吗？

        答：抽象类可以用构造器，并用构造函数用来初始化抽象类的一些字段，构造函数的应用：在其内部实现子类必须执行的代码

           2.抽象的作用？

        答：把类的公共方法抽取出来，减少代码量，提高开发效率。

接口

package com.company.oop;

//interface 定义的关键字，接口都需要有实现类
public interface UserService {
    //接口中的所有定义其实都是抽象的public obstract
    void Add(String name);
    void Delete(String name);
    void Updata(String name);
    void Query(String name);
}

package com.company.oop;

public interface two {
    void niuma();
}

package com.company.oop;

//快捷键Alt+Enter
//抽象类：extend
//类 可以实现接口implements 接口
//实现了接口的类，就需要重写接口中的方法
public class UserServiceImpl implements UserService,two{//这里可以实现两个接口
    @Override
    public void Add(String name) {

    }

    @Override
    public void Delete(String name) {

    }

    @Override
    public void Updata(String name) {

    }

    @Override
    public void Query(String name) {

    }

    @Override
    public void niuma() {
        //这里实现了第二个方法
    }
}

将它们创建在oop软件包下

异常

 异常处理机制：

1.抛出异常

2.捕获异常

异常处理的五个关键字：

        try、catch、finally、throw、throws

异常处理快捷键Ctrl + Alt + T

 

更新于2022.4.30