Java的三大特征之一（封装）

概念：

对象代表什么，就得封装对应的数据，并提供数据对应的行为

封装就是把属于同一类事物的共性放到一个类中，便以使用（狭义）。是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

封装的好处

 将变化隔离、便于使用、提高重用性、提高安全性

封装的通常做法：

（1）将类的属性的访问权限设置为private，提供访问权限为public的set和get方法。在有些情况下不提供set和get方法，有时只提供其中的一个。

（2）提供合理的构造方法，即开发相应参数的构造方法，方便实例化对象。

（3）类的全部或部分方法的访问权限为public，类的公有方法是类对外开放的接口，供外部代码使用类的功能。类的私有方法通常是辅助方法实现部分功能，供类的公有方法调用。

public class Box {
    private int c;
    private int a;
    private int b;

    public int getC() {
        return c;
    }

    public void setC(int c) {
        this.c = c;
    }

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public int getB() {
        return b;
    }

    public void setB(int b) {
        this.b = b;
    }



    public Box() {
    }

    public Box(int a, int b, int c) {
            this.a = a;
            this.b = b;
            this.c = c;
        }
        public int volume(){
            int product = a*b*c;
            System.out.println("这个长方形的面积是："+product);
            return product;
        }
}

public class Box_test {
    static Scanner sc = new Scanner(System.in);
    public static void main(String[] args) {
        System.out.println("请输入你要输入的长方体的长：");
        int a = sc.nextInt();
        System.out.println("请输入你要输入的长方体的宽：");
        int b= sc.nextInt();
        System.out.println("请输入你要输入的长方体的高：");
                int c= sc.nextInt();
                Box box = new Box(a,b,c);
                box.volume();
    }
}

public class Circle {
    private double r;

    public double getR() {
        return r;
    }

    public void setR(double r) {
        this.r = r;
    }

    public Circle() {
    }
    public void cirle(double r){
        this.r= r;
    }
    public void area(){
        System.out.println("圆形的面积是"+r*r*3.14);
    }
}

public class Circle_test {
    public static void main(String[] args) {
        Circle circle = new Circle();
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入圆的半径");
        double r1 = sc.nextDouble();
        Circle circle1 = new Circle();
        circle1.setR(r1);
        circle1.area();
    }
}

private关键字

是一个权限修饰符

可以修饰成员（成员变量和成员方法）

被private修饰的成员只能在本类中才能访问

针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作，

提供setXxx(参数)方法，用与给成员变量赋值，方法用public修饰

提供getXxx()方法，用与获取成员变量的值，方法用public修饰

四个修饰符

类成员的访问范围划分为四个：本类、本包、子类、全局（所有包）

为类的成员指定不同的修饰符，就是控制成员的在什么样的范围内是可见的，即在什么样的范围是能够访问的。

	private	默认	protected	public
同一个类中	是	是	是	是
相同包中的其他类	否	是	是	是
子类(不同包、相同包)	否	否	是	是
全局（所有包）	否	否	否	是

访问范围：  本类   <  本包   <  子类  < 全局（所有包）

访问修饰符：private  <  （default） < protected  <  public

重载

在类中可以定义名称相同的方法：只要形参列表不同即可。

特点：

• 1、方法名相同
• 2、形参列表不同：形参的类型/顺序、形参的个数

注意的地方：

• 1、返回值在区分重载方法时不起作用。修饰符也不起作用
• 2、当调用重载方法时，Java使用参数的类型和/或数量确定实际调用哪个版本。

• public class Testday01{
      {
          return x+y;
      }    
   
      static int add(int x, int y, int z)
      {
          return x+y+z;
      }
   
      static double add(double x, double y)
      {
          return x+y;
      }
   
      
      public static void main(String[] args) {
          int i;
          double d;
      i = add(4,5);
      System.out.println(i);
      i = add(3,4,5);
      System.out.println(i);
      d = add(4.3 , 7.7);
      System.out.println(d);
      }
  }