Java07面向对象01

迈不过友情╰ 2024-03-25 10:39 84阅读 0赞

## 1 初识面向对象 ##

### 1.1 面向过程&面向对象 ###

1）面向过程思想：  
（1）步骤清晰简单；  
（2）适合处理较为简单的问题；

2）面向对象思想：  
（1）物以类聚，`分类`的思维模式，思考解决问题需要哪些分类，然后对这些分类单独思考，最后对某个分类进行面向过程的思考；  
（2）面向对象适合处理复杂的问题，适合需要多人协作的问题；

3）`对于描述复杂的事物，为了从宏观上把握、从整体上分析，我们需要使用面向对象的思想来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思想去处理`。

### 1.2 什么是面向对象 ###

1）面向对象编程（Object-Oriented Programming，OOP）  
2）面向对象编程的本质就是 **：`以类的方式组织代码，以类的方式组织（封装）数据`；**  
3）抽象：编程思想！持续的学习后才会有所理解；多实践多测试自己的想法；  
4）面向对象三大特性：  
（1）**`封装`**  
（2）**`继承`**  
（3）**`多态`**  
5）从认识论角度考虑是先有对象后有类。**`对象`是具体的事物**。**`类` 是抽象的，是对对象的抽象**；  
6）从代码运行角度考虑先有类后有对象。类是对象的模板。

## 2 方法回顾加深 ##

### 2.1 方法的定义 ###

> 1.  修饰符
> 2.  返回类型
> 3.  `break 跳出switch，结束循环 和return的区别`
> 4.  方法名:见名知意、驼峰命名
> 5.  参数列表：参数类型、参数名
> 6.  异常抛出

/**由 class修饰的是类名*/
    public class Demo01ReplayMethod {
        
        // main主方法（一般一个程序中只有一个）
        public static void main(String[] args) {
        
    
        }
        /*
        修饰符 返回值类型 方法名(){
            // 方法体
            return 返回值;//返回值要和返回值类型一致
        }
         */
        //return 结束方法，返回一个结果
        public String sayHello(){
        
            return "Hello";
        }
        public void hello(){
        
            return;
        }
        //入参
        public int max(int a, int b){
        
            return a>b ? a: b;//三元运算符
        }
        //异常
        public void readFile(String file) throws IOException {
        
            return;
        }
    }

### 2.2 方法的调用 ###

> 1.  静态方法
> 2.  非静态方法
> 3.  **形参和实参**

public class Employee {
        
        //static修饰的方法 是和类一起加载的
        public static String say(){
        
            return "发工资了哦";
        }
        //没有用static修饰的方法 是在实例化后才存在
        public String write(){
        
            //因此非静态方法 可以调用静态方法
            say();
            return "报销单";
        }
        //形式参数
        public int add(int a, int b){
        
            return a+b;
        }

public class Demo02MethodInvocation {
        
        public static void main(String[] args) {
        
            /*1.调用静态方法：类名.方法名 */
            String say = Employee.say();
            System.out.println(say);
    
            /*2.调用非静态方法：实例化对象`new`后，再调用 */
            Employee employee = new Employee();
            String write = employee.write();
            System.out.println(write);
    
    		/*3.实参*/
            int sum = employee.add(1, 2);
            System.out.println(sum);
        }
    }

> 1.  **值传递和引用传递**

package com.f.oop;
    //值传递
    public class Demo03PassByValue {
        
        public static void main(String[] args) {
        
            int a= 1;
            System.out.println(a);//1
    		
            new Demo03PassByValue().change(1);
            System.out.println(a);//1
        }
        public void change(int a){
        
            a= 10;
        }
    }

/**
     * pass by reference 引用传递
     * 传递的是对象，本质还是值传递
     * 难点：`对象`的理解；`内存`的理解
     */
    public class Demo04Reference {
        
        public static void main(String[] args) {
        
            Person person = new Person();
            System.out.println(person.name);//null
    
            Demo04Reference.change(person);
            System.out.println(person.name);//tom
    
        }
        public static void change(Person person){
        
            /* person是一个对象，指向的是：
            Person person = new Person();
            是一个对象（具体的人），可以改变*/
            person.name= "tom";
        }
    }
    /** 定义一个 person类，有一个属性：name */
    class Person{
        
        String name;
    }

> 1.  `this关键字`：当前对象，当前类

## 3 对象的创建和分析 ##

### 3.1 类对象的关系 ###

`1）类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一具体的事物`。  
（示例\_1）动物、植物、手机、电脑…  
（示例\_2）Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物具备的特点和行为

package com.f.oop2Constructer;
    //员工类: 就是一个模板
    public class Employee {
        
        //1.属性：字段
        String name;
        int age;
    
        //2.方法
        public void work(){
        
            //this:指代当前类
            System.out.println(this.name+"在工作");
        }
    }

`2）对象是抽象概念的具体实例`  
（示例\_3）Tom是人的一个具体的实例。  
（示例\_4）能够体现出特点，展现出功能的是具体的实例，而不是抽象的概念。

package com.f.oop2Constructer;
    // 一个项目应该只有一个 main方法
    public class Application {
        
        public static void main(String[] args) {
        
            /*
            类：是抽象的，实例化后会返回一个自己的对象！
            employee对象就是一个 Employee类的具体实例！ */
            Employee tom = new Employee();
            Employee jerry = new Employee();
    
            tom.name = "汤姆";
            tom.age = 18;
            System.out.println(tom.name);
            System.out.println(tom.age);
    
            jerry.name = "杰瑞";
            jerry.age = 16;
            System.out.println(jerry.name);
            System.out.println(jerry.age);
        }
    }

### 3.2 创建与初始化对象 ###

1）**使用 `new关键字创建对象`**。创建时除了分配内存空间，还会给创建好的对象 进行默认初始化，和对类中的**构造器**的调用；  
2）*类中的构造器*：也称为构造方法，是在创建对象的时候必须要调用的。  
3）**`构造器`有以下两个特点：**  
**（1）`必须和类的名字相同`；  
（2）`必须没有返回类型，也不能写 void`。**  
4）构造器的作用：  
（1）使用 new关键字，其本质还是在调用构造器；  
（2）用来`初始化值`  
5）注意点：  
（1）：一旦定义了有参构造，必须显式定义无参构造  
快捷键：Alt + Insert

package com.f.oop2Constructer;
    /**
     * 显式定义构造器
     * 一个类即使什么也不写，它也会存在一个方法
     */
    public class Company {
        
        String name;
        //无参构造
        public Company() {
        }
        //有参构造
        public Company(String name) {
        
            this.name = name;
        }
    }

package com.f.oop2Constructer;
    
    /**一个项目应该只有一个 main方法!
     * 类：是抽象的，实例化后会返回一个自己的对象！*/
    public class Application {
        
        public static void main(String[] args) {
        
            //new 实例化对象
            Company company = new Company("xyd");
            System.out.println(company.name);
        }
    }

### 3.3 回顾总结 ###

1.  类与对象：  
    类是一个模板，它是抽象的；对象是一个具体的实例
2.  方法：  
    方法的定义、方法的调用
3.  对象的引用：  
    引用类型；基本类型（8种）；  
    对象是通过引用来操作的：栈（存的是地址）----堆（内容）。
4.  属性：字段Field 成员变量  
    修饰符 属性类型 属性名 = 属性值;  
    默认初始化：  
    数字：0、0.0；  
    char：u0000；  
    Boolean：false；  
    引用类型：null。
5.  对象的创建和使用：  
    5.1 必须使用 new关键字创建对象；  
    5.2 构造器：Employee tom = new Employee();  
    5.3 对象的属性：tom.name  
    5.4 对象的方法：tom.work();
6.  类：  
    静态的属性：即属性；  
    动态的行为：即方法。