1对象初始化封装、2封装操作流程、3内部数据封装、4.访问控制修饰符5.不定长自变量6.内部类

1.对象初始化流程封装

　　对象的构造函数实现对象初始化流程的封装。

　　

class dog{
    String name;
    dog(String name){
            this.name=name;
     } 
　　public static void mian(String[] args){
　　　　dog b=new dog();b.name="大黄"//未编写构造函数之前
　　　　dog a=new dog("大黄");
}    

2.对象操作流程的封装

　　对象的方法封装了操作的流程

 card card1=new card(0);
 Scanner scanner=new Scanner(System.in);
 card1.store(scanner.nextInt());

3.对象内部数据的封装

　　把对象的数据定义为私有private时这些数据就是类所私有的，想要获取私有的数据就要通过对象定义的流程或者说是相关的方法来获取否则无法获取这样做可以增加数据的安全性。

package Learn;
import java.util.Scanner;
public class fengzhuang {
    private void mian() {
        card card1=new card(0);
        Scanner scanner=new Scanner(System.in);
        card1.store(scanner.nextInt());
        card1.getMonney();
    }
}
class card{
    private int monney;
    card(int money){
        this.monney=money;
    }
    void store(int money){
        this.monney+=money;
    }
    public int getMonney() {//获取私有数据的方法
        return monney;
    }
    public void setMonney(int monney) {
        this.monney = monney;
    }
    
}

4.访问控制修饰符

	类内	包内	子类	任意
public	√	√	√	√
protected	√	√	√
default	√	√
private	√

　　

5.不定长自变量

public static void main(String[] args) {
        Moo a=new Moo();
        int sum1=Moo.sum(1,2,2);
        int sum2=Moo.sum(1,2);
    }
public static int sum(int...numbers){//声明的参数类型后面加上...。实现不定长自变量不定长的参数必须放在所有参数类型的最后一个。
    int sum=0;
    for(int number:numbers){
        sum+=number;
    }
    return sum;
}

6.内部类

　　定义

　　　　内部类作为外部类的一个成员依附于外部类而存在。内部类可以为静态类，可以用private和protected修饰（而外部类只能使用public和缺省的包访问权限）

　　为什么需要内部类

　　　　典型的情况是每个内部类都能独立的继承一个（接口）实现，所以外围类是否已经继承对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类

　　　　的能力，一些设计和编程久很难实现。内部类使得多重继承的解决方案变得完整，内部类有效地解决了多重继承。

　　静态内部类

　　　　static修饰声明在类中。

　　　　静态内部类可以访问外部类的静态成员。

　　成员内部类

　　　　声明在类体中，不适用static，具体类的成员特征。必须有类的实例才能创建内部类的实例

　　　　内部类的实例可以访问外部类的成员变量。

　　局部内部类

　　　　把类声明在方法中。

　　匿名内部类

　　　　匿名类可以写在任何地方，就像一般的语句

　　　　语法更像是创建对象

　　　　匿名类是对原类的一个继承

　　　　匿名类不能写构造器

　　　　匿名类可以从抽象类继承或者接口继承

　　　　任何的内部类都会编译为.class文件