Java-封装

一，构造器（或构造方法）constructor

不能被继承，只能调用，我们创建子类的对象是必须调用父类的构造方法（默认调用空参构造方法）

1.构造器的作用：创建对象。

例：student p1 = new student( )
初始化对象的属性。

2.说明：

（1）如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器；

​ （2） 定义构造器的格式：权限修饰符 类名（形参）{ }

​ （3）一个类中定义的多个构造器，彼此构成重载

​ （4）一旦我们显式的定义了类的构造器之后，系统就不再提供默 认的空参构造器。

二，this 关键字

1. this.属性 指当前对象的属性

2.this可以用来修饰：属性，方法，构造器

3.this通常用在类的构建中，当属性和形参取名相同时来区分形参和属性

4.this调用构造器，例:
(1) publilc person( ){ }

​ （2）public person（ String age ）{ }

​ （3）public person（ int id ， String name ）{ }

​ 第一种调用方法：this（）默认调用无参构造器

​ 第二种调用方法：this（ age ）

​ 第三种调用方法：this（id ， name）

​ 5.在构造器内调用构造器时只能调用本类的其他构造器，且构造器与构造器间不能形成闭环。构造器内部只能调用一个其他构造器且要放在首行。

三，权限修饰符: private , public , 缺省 , protected

	public	protected	缺省(default)	private
同一个类	yes	yes	yes	yes
同一个包	yes	yes	yes	no
不同包子类	yes	yes	no	no
不同包非子类	yes	no	no	no

什么是封装？

将相似的对象，放在一起，提取出来相同的属性以及方法的过程叫做抽象，将通过抽象过程提取的属性与方法重新放置在一个范本里面，这个范本就是类型，而生成这个范本的过程叫做封装。

封装生成了一个类型，通过这个类型创建一个对象的过程叫做实例化。

封装时，针对可以用名词定义的特征叫做属性，可以用动词定义的特征叫做方法。

当我们创建一个对象的时候，就等于我们创建了一个整体，里面包含了类指代的所有属性以及方法。

在我们封装一个类型时，我们需要同时指定这个类型所具有的属性以及方法的访问控制。包括，公开，友元，默认（包）， 私有，这些个过程分别对应任何地方都能访问，有关系才能访问，同一个包内可以访问，只能在该类型中访问。

同时，我们学习了方法，方法应该具有返回值类型，方法名， 参数列表， 方法体。

一个类型中不能出现同名的属性，但是一个类型中可以通过参数列表的不同，

出现同名的方法，这个过程我们叫做重载。

构造方法： 是用来创建对象的方法，构造方法一般用来初始化对象应该具有的属性。

一个类型其实必然有一个构造方法，当我们没有显性的定义一个构造方法的时候，那么JAVA会给我们一个默认的，没有参数列表，没有方法体的构造方法。

但是如果我们定义了一个构造方法，那么这个默认的构造方法就会消失不见。

构造方法一定要注意，其没有返回值类型（void也是一种返回值类型，不是说

构造方法返回的类型是void）构造方法的方法名一定要和类名保持一直，且大小写敏感。

所有的方法和属性，都可以加上访问控制，这里要注意。构造方法也是方法，也可以加上访问控制。如果在构造方法上加上访问控制private，那么这个类型的对象只能由这个类型自己创建，别人创建不了。

package edu.yau.exercise;

import java.util.Arrays;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

    //初始化用户输入

    Scanner scanner = new Scanner(System.in);

    int n = scanner.nextInt();

    int m = scanner.nextInt();

    int[] per = new int[n];

    for(int i = 0; i<n ; i++) {

        per[i] = scanner.nextInt();

    }

    //初始化结束

    //初始和

    int result = 0;

    for(int i = 0; i<per.length; i++) {

        result = result + per[i];

    }

  
    //全队20% debuff

    result = result - 2 * result / 10;

    //志愿者产生的效率

    int[] tempPer = new int[n * 4];

    for(int i = 0; i<per.length; i++) {

        int temp = per[i] / 10;

        tempPer[i * 4] = 2 * temp;

        tempPer[i * 4 + 1] = temp;

        tempPer[i * 4 + 2] = temp;

        tempPer[i * 4 + 3] = temp;

    }

    //计算完成所有志愿者可能带来的效率提升

    //对可能的效率提升数组进行排序

    for(int i = 0; i< tempPer.length ; i++) {

        for(int j = 0; j < tempPer.length; j++) {

            if(tempPer[i] < tempPer[j]) {

                int temp = tempPer[j];

                tempPer[j] = tempPer[i];

                tempPer[i] = temp;

            }

        }

    }

    //排序完成

    //根据志愿者的个数，开始加数组内容

    for(int i = 0; i < m; i++) {

        if(i >= tempPer.length - 1) {

            result += tempPer[i];

        }

    }


    System.out.println("一共有：" + n + "个大白");

    System.out.println("一共有：" + m + "个志愿者");

    System.out.println("效率统计是：" + Arrays.toString(per));

    System.out.println("初始效率和是：" + result);

    System.out.println("志愿者可能产生的效率：" + Arrays.toString(tempPer));

  

    }        

}