标签：name 对象 void 封装数据 面向对象编程 new Day18 public String

# 面向对象编程

Java的核心思想就是OOP(面向对象编程)

1.初识面向对象

面向过程&面向对象

​ 属性+方法=类

面向过程思想

​ 步骤清晰简单，第一步做什么，第二步做什么

​ 面对过程适合处理一些较为简单的问题

面向对象思想

​ 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考，最后，才对某个分类下的细节进行面向过程的思索。

​ 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！

就像学方法一样，自己写也可也，但是有人写好了我们可以直接拿来调用，这就是面向对象

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

什么是面向对象

面向对象编程（Object-Oriented Programming,OOP）

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

抽象（abstraot）：简化的意思，就是把某个东西简化成几个点

三大特性

​ 封装

​ 继承：子类继承父类

​ 多态：因为继承，所以有多态

封装就是第一题，第二题，或者语文卷子，数学卷子

继承就是直角三角形继承自三角形，前者是后者的子类

而继承必然导致多态，有直角三角形，就必然有非直角三角形等等

​ 从认识论角度考虑是先有对象后有类。对象：是具体的事物。类，是抽象的，是对对象的抽象

​ 从代码运行角度考虑是现有类后有对象。类是对象的模板

2.方法回顾和加深

方法的定义

​ 修饰符

​ 返回值类型

​ break和return的区别：break：跳出switch结素循环；return 结束循环

​ 方法名：注意规范 见名知意

​ 参数列表：参数类型，参数名…可变长参数

​ 异常抛出：疑问后面讲解

package com.oop;

import java.io.IOException;

//Demo01 类
public class demo01 {

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

    }

    /*
    修饰符 返回值类型 方法名（...参数）{
        //方法体
        return 放回值；
    }
     */
    public String sayHello(){
        return "hello world"
    }

    //void是空
    //return结束方法 返回值或空
    public void hello(){
        return;
    }

    //a，b形参
    public int max(int a,int b){
        return a>b ? a : b;//三元运算符
    }

    //数组下标越界：Arrayindexoutofbounds

    //异常抛出的方法才是完整的
    public void readFile(String file) throws IOException{

    }
}

方法的调用：调用

​ 静态方法

public class Student {
//静态方法
public static void say(){
    System.out.println("学生说话");
}
}

静态调用

public class Demo02 {

    public static void main(String[] args) {
        Student.say();//静态方法调用
    }
}
        

​ 非静态方法：避免了外部直接调用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yxLQozY3-1645627593021)(D:\Javanotebooks\jietu\92.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9qyS3IoX-1645627593022)(D:\Javanotebooks\jietu\93.png)]

所以：静态方法和非静态方法之间并不能调用

形参和实参

​ 值传递和引用传递

​ this关键字

eg：对象A的名字叫张三，对象B的名字叫李狗蛋。对象的名字属性都有自己独一无二的值

由于static修饰的表示属于类，因此如果想访问类的方法或者变量，则可以直接通过类名.方法名（） / 类名.变量 进行访问

所谓动态和静态的方法，对于一个类来说，如果没有被static修饰的成员变量或成员方法，那么每实例一个新的对象（new），这些非static所修饰的类都属于对象

非静态的调用得先new

形参和实参

package com.oop;

public class Demo03 {
    public static void main(String[] args) {
        //实际参数和形式参数类型要相同
        int add = new Demo03().add(1, 5);
        System.out.println(add);
    }

    public int add(int a, int b){
        return a+b;
    }


}

值传递和引用传递

值传递：复制一份，引用传递：新建快捷方式

package com.oop;

public class Demo04 {
    public static void main(String[] args) {
        int a =1;
        System.out.println(a);//1

        Demo04.change(a);

        System.out.println(a);//1
    }

    //返回值 为空
    public static void change(int a){
        a=10;
    }

}

package com.oop;

//引用传递：对象，本质还是值传递

//对象，内存

public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person);//null

        //非同类非静态用对象调用
        Demo05.change(person);
        System.out.println(person);//子聿
    }

    public static void change(Person person){
        //Person是一个对象：指向的是 Person person = new Person();可以改变属性
        person.name = "子聿";
    }
}

//定义了一个Person类,有一个属性name,并不是内部类
class Person{
    String name;
}

this关键字：代表当前这个类或当前这个对象

类和对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。

​ 动物、植物、手机、电脑…

​ Person类、Pet类、Car类等、这些都是用来秒速/定义某一类具体的事物应该具备的特点和行为

对象是抽象概念的具体实列

​ 张三就是人的一个具体实列，张三家里的旺财就是狗的一个具体实例

​ 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念

创建和初始化对象

​ 使用new关键字创建对象

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

package com.oop.demo02;

//学生类（一个类只存在属性和方法）
public class Student {
    //属性：字段
    String name;//NULL 默认
    int age;//NULL o

    //方法
    //学生类是学生的属性（姓名） 方法（能干什么）
    //创建的学生对象是一个具体的学生（有头有脸）
    public void study(){
        System.out.println(this.name+"在学习");//学生在学习，但是学生是变化的，所以用this来指代
    }


}

//person-->身高，体重等
//学程序好：对世界进行更好的建模！
//面向对象编程:以类的方式组织代码，以对象的组织封装数据

package com.oop.demo02;

//一个项目应该只存在一个main方法（总测试类）
public class Application {
    public static void main(String[] args) {

        //类：抽象的，实例化
        //类实例化之后会返回一个自己的对象
        //student对象就是一个Student类的具体实例
        Student student = new Student();
        Student xiaoming = new Student();
        Student xh = new Student();


        xiaoming.name ="小明";
        xiaoming.age = 18;

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);


        xh.name ="小红";
        xh.age = 19;

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);
    }
}

构造器

类中的构造器也称为构造方法，是在进行创建对象的时候必须调用的，并且构造器又以下两个特点：

​ 1.必须和类的名字相同

​ 2.必须没有返回值类型，也不能写void

构造器必须要掌握

1.一旦定义了有参构造，无参就必须显示定义
2.用来初始化值

alt+insert：生成构造器

//一旦定义了有参构造，无参就必须显示定义

package com.oop.demo02;

//java--->class
public class Preson {

    //一个类即使什么都不写，他也会存在一个方法

    String name;
    String age;


    //无参构造器
    //实例化初始值
    //1.使用new关键字，本质是在构造器
    public Preson(){

    }

    //有参构造器
    //1.一旦定义了有参构造，无参就必须显示定义
    //2.用来初始化值
    public Preson(String name){
        //this.name代表的是参数传下来的name ，
        // 而后面的name是有参的name
        this.name = name;
    }
    //alt+insert生成构造器


}
/*
 public static void main(String[] args) {
       //new 实例化了一个对象
        Preson preson = new Preson();
        System.out.println(preson.name);

    }
 */

构造器：
1.和类名相同
2.没有返回值
作用：
new本质调用构造器
初始化对象的值
注意点
1.定义了有参构造之后想使用无参构造，显示的定义一个有参构造

3.对象的创建分析

4.面向对象的三大特征

5.抽象类和接口

6.内部类及OOP实战

lt+insert生成构造器

}
/*
public static void main(String[] args) {
//new 实例化了一个对象
Preson preson = new Preson();
System.out.println(preson.name);

}

*/

**构造器：**
**1.和类名相同**
**2.没有返回值**
**作用：**
**new本质调用构造器**
**初始化对象的值**
**注意点**
**1.定义了有参构造之后想使用无参构造，显示的定义一个有参构造**

标签：name,对象,void,封装数据,面向对象编程,new,Day18,public,String
来源： https://blog.csdn.net/h1776842314/article/details/123101280

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。