Java 객체지향의 특징과 사용법은 무엇입니까?

프로세스 지향과 객체 지향의 차이점

프로세스 지향: 이벤트가 비교적 단순한 경우 프로세스 지향을 사용합니다. 이벤트의 특정 단계와 프로세스에 초점을 맞추고 프로세스의 특정 동작에 초점을 맞추고 가장 작은 단위로 기능을 수행하는 방법을 고려하십시오.

객체 지향: "참여자" 찾기에 집중하고, 기능을 객체로 캡슐화하고, 객체를 기능으로 강조하고, 클래스/객체를 가장 작은 단위로 삼고, 누가 그것을 할 것인지 고려합니다.

사례: Xiao Ming이 냉장고에서 무언가를 가져옵니다.

프로세스 지향:

객체 지향:

프로세스 지향—> the executor Transition

클래스와 객체의 관계

모든 것이 객체입니다

객체: 특정 사물, 특정 엔터티, 특정 인스턴스, 템플릿 아래의 특정 제품

클래스: 객체에서 위쪽으로 이미지 부분을 추출하고 게시합니다. 클래스는 추상이고 템플릿입니다. 일반적으로 코드를 작성할 때 클래스를 먼저 작성한 다음 클래스를 기반으로 해당 객체를 생성합니다. 클래스 인스턴스화 및 객체 생성

클래스 생성

1. 속성(필드 멤버 변수)

속성은 이 클래스 또는 이 클래스의 객체에 포함된 데이터 또는 정적 특성을 정의하는 데 사용됩니다. 속성의 범위는 전체 클래스 본문입니다.

속성 정의 형식:

[modifier] 속성 유형 속성 이름 = [기본값];

2. 메서드

메서드는 이 클래스 또는 이 클래스의 인스턴스의 동작 특성과 기능적 구현을 ​​정의하는 데 사용됩니다. 메소드는 클래스와 객체의 동작 특성을 추상화한 것입니다. 메소드는 절차지향 프로그래밍의 함수와 매우 유사합니다. 프로세스 지향에서는 함수가 가장 기본적인 단위이며 전체 프로그램은 함수 호출로 구성됩니다. 객체지향에서는 전체 프로그램의 기본 단위가 클래스이고, 메소드는 클래스와 객체에 종속됩니다.

메소드 정의 형식:

[수정자] 메소드 반환 유형 메소드 이름(정식 매개변수 목록) {

//Java 문

}

위의 영광의 왕 영웅 클래스 생성을 예로 들어보겠습니다. :

//创建英雄类
public class Hero {
    //属性
    String Name;//英雄姓名
    int Survive;//生存能力
    int Attack;//攻击伤害
    int Skill;//技能效果
    int Difficulty;//上手难度

    //技能
    public void Kill(int number){
        //根据输入的数字释放几技能
        System.out.println(Name+"释放"+number+"技能！！！");
    }
    //输出该英雄的属性
    public void print(){
        System.out.println("英雄："+Name);
        System.out.println("生存能力："+Survive);
        System.out.println("攻击伤害："+Attack);
        System.out.println("技能效果："+Skill);
        System.out.println("上手难度："+Difficulty);
    }

}

객체 생성

다음으로 생성한 클래스에 대한 객체를 생성합니다

public class TestCode01 {
    //main方法，程序的入口
    public static void main(String[] args) {
        //创建一个对象(英雄)-->马克波罗
        Hero make = new Hero();
        make.Name = "马克波罗";
        make.Survive = 4;
        make.Attack = 6;
        make.Skill = 6;
        make.Difficulty = 5;
        //再创建一个英雄-->澜
        Hero lan = new Hero();
        lan.Name = "澜";
        lan.Survive = 3;
        lan.Attack = 5;
        lan.Skill = 4;
        lan.Difficulty = 6;
        lan.Kill(1);
        //输出两个英雄的属性
        make.print();
        System.out.println("-------------");
        lan.print();
        //释放技能
        make.Kill(3);
        System.out.println("-------------");
        lan.Kill(2);
    }
}

결과: 각 영웅은 동일한 속성을 가지며 각 속성은 다른 값을 갖습니다. 클래스를 통해 각각 여러 객체를 생성할 수 있습니다. 객체에는 다른 속성 값이 있습니다.

예: King of Kings에는 각각 다른 특성을 지닌 100명 이상의 영웅이 있습니다.

객체 생성 과정:

(1) 클래스를 처음 만날 때 클래스는 한 번만 로드되어야 합니다.

(2) 객체를 생성하고 힙에 공간을 엽니다.

(3) 객체를 초기화하고 속성 할당은 모두 기본 초기 값입니다.

(4) new 키워드는 생성자를 호출하고 생성 메서드를 실행하며 생성자

Constructor

객체에서 속성을 다시 할당합니다. new 키워드는 실제로 메서드를 호출하는 것입니다( 생성자)

생성자를 호출할 때 클래스에 작성된 생성자가 없으면 시스템에서 기본적으로 생성자(빈 생성자)를 할당합니다.

생성자 메서드 형식:

[ 수정자] 생성자 이름() {

}

생성자와 메소드의 차이점:

메소드의 반환 값이 없습니다.

메소드 본문 내부에는 반환 문이 있을 수 없습니다.

• 생성자의 이름 매우 특별합니다. , 클래스 이름과 일치해야 합니다

• 생성자의 역할: 객체를 생성하지 않는 것입니다. 객체는 생성자가 호출되기 전에 이미 생성되었으며 속성에는 기본 초기화 값이 있기 때문입니다.
• 생성자를 호출하는 목적은 속성에 값을 할당하는 것입니다.
  참고: 일반적으로 빈 생성자에서는 초기화하지 않습니다. 왜냐하면 초기화하면 각 객체의 속성이 동일하기 때문입니다.

다음 예:

class Hero{
    //属性
    String Name;//英雄姓名
    int Survive;//生存能力
    int Attack;//攻击伤害
    int Skill;//技能效果
    int Difficulty;//上手难度

    public Hero(){
        Survive=4;
        Attack=5;
        Skill=6;
        Difficulty=7;
    }
    public void print(){
        System.out.println("英雄："+Name);
        System.out.println("生存能力："+Survive);
        System.out.println("攻击伤害："+Attack);
        System.out.println("技能效果："+Skill);
        System.out.println("上手难度："+Difficulty);
    }
}
public class TestCode01 {
    public static void main(String[] args) {
        //创建两个英雄对象
        Hero make = new Hero();
        make.Name="马克";
        Hero lan=new Hero();
        lan.Name="澜";
        //输出两个属性
        make.print();
        lan.print();
    }
}

생성자에 값을 할당했기 때문에 객체를 생성할 때 속성은 동일합니다

실제로는 빈 생성자의 존재만 확인하면 됩니다. 내부 내용을 작성할 필요가 없습니다. 생성자를 사용하여 값을 할당하려면 생성자를 오버로드해야 합니다

생성자 오버로딩

일반적으로 빈 생성자가 있는지 확인하고 속성 할당 작업은 일반적으로 빈 상태에서 수행되지 않습니다. constructor

일반적으로 생성자를 오버로드하고 오버로드된 생성자에서 속성 할당 작업을 수행합니다

在重载构造器以后，假如空构造器忘写了，系统也不会给你分配默认的空构造器了，那么你要调用的话就会出错了。所以我们重载构造器时，一般要保留默认构造器

当形参名字和属性名字重名的时候，会出现就近原则：在要表示对象的属性前加上this.来修饰 ，因为this代表的就是你创建的那个对象

this的使用

this就是指当前的对象

this可以修饰属性

当属性名字和形参发生重名的时候，或者 属性名字 和局部变量重名的时候，都会发生就近原则，所以如果我要是直接使用变量名字的话就指的是离的近的那个形参或者局部变量，这时候如果我想要表示属性的话，在前面要加上：this.修饰（如果不发生重名问题的话，实际上你要是访问属性也可以省略this.）

this修饰方法

在同一个类中，方法可以互相调用，this.可以省略不写。

this可以修饰构造器

同一个类中的构造器可以相互用this调用，注意：this修饰构造器必须放在第一行

static修饰

static可以修饰：属性、方法、代码块、内部类

static修饰属性

在类加载的时候，会将静态内容也加载到方法区的静态域中，静态的内容先于对象存在，并且这个静态内容被所有该类的对象共享。

• 在类加载的时候一起加载入方法区中的静态域中

• 先于对象存在

• 访问方式： 对象名.属性名 类名.属性名（推荐）

static修饰属性的应用场景：某些特定的数据想要在内存中共享，只有一块 -->这个情况下，就可以用static修饰的属性。

static修饰方法：

• static和public都是修饰符，并列的没有先后顺序，先写谁后写谁都行

• 在静态方法中不能使用this关键字

• 在静态方法中不能访问非静态的方法

• 在静态方法中不能访问非静态的属性

• 静态的方法可以用 对象名.方法名去调用 也可以 用 类名.方法名 （推荐）

• 在同一个类中可以直接调用静态方法

代码块

代码块的分类： 普通块、构造块、静态块、同步块（多线程）

代码块执行顺序： 最先执行静态块–>再执行构造块，（不常用）–>再执行构造器–>再执行方法中的普通块

public class Test {
    //属性
    int a;
    static int sa;
    //方法
    public void a(){
        System.out.println("-----a");
        {
            //普通块限制了局部变量的作用范围
            System.out.println("这是普通块");
            System.out.println("----000000");
            int num = 10;
            System.out.println(num);
        }

    }
    public static void b(){
        System.out.println("------b");
    }
    //构造块
    {
        System.out.println("------这是构造块");
    }
    //静态块
    static{
        System.out.println("-----这是静态块");
        //在静态块中只能方法：静态属性，静态方法
        System.out.println(sa);
        b();
    }
    //构造器
    public Test(){
        System.out.println("这是空构造器");
    }
    public Test(int a){
        this.a = a;
    }
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Test t = new Test();
        t.a();
        Test t2 = new Test();
        t2.a();
    }
}

包（import）

包的作用： 为了解决重名的作用，解决权限问题

包名的定义：

• 名字全部小写

• 中间用.隔开

• 一般都是公司域名倒着写：com.jd 、com.taobao

• 加上模块名字 ：com.taobao.login

• 不能使用系统中的关键字：null

• 包声明的位置一般都在非注释代码的第一行

导包：

（1）使用不同包下的类要需要导包， 例如：import java.util.Date;

（2）在导包以后，还想用其他包下同名的类，就必须要手动自己写所在的包。

（3）同一个包下的类想使用不需要导包，可以直接使用。

（4）在java.lang包下的类，可以直接使用无需导包

（5）可以直接导入*：

静态导入：

//静态导入：
import static java.lang.Math.*;
//导入：java.lang下的Math类中的所有静态的内容

public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
        System.out.println(round(5.6));
    }
    //在静态导入后，同一个类中有相同的方法的时候，会优先走自己定义的方法。
    public static int round(double a){
        return 1000;
    }
}

위 내용은 Java 객체지향의 특징과 사용법은 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!