java对象markword里面都有啥

面对对象的特征一:封装与隐藏

一、问题的引入:
当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到
属性的数据类型和存储范围的制约，除此之外，没用其它的制约条件。但是，在实际问题中，我们往往需要给属性赋值
加入额外的限制条件。这个限制条件不能在属性声明时体现，我们只能通过方法进行限制条件的添加。(比如setLegs)
同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private)
–>此时，针对于属性就是体现封装性。

二、封装性的体现:
我们将类的属性xxx私有化(private)，同时设置，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值

拓展:封装性的体现:1、如上 2、不对外暴露的私有的方法 3、单例模式…

三、封装性的体现，需要权限修饰符来配合
1.java规定的4种权限（从小到大排列）:private、缺省、protected、public
2.4种权限可以用来修饰类及类的内部结构:属性、方法、构造器、内部类
3.具体的，4种权限都可以用来类的内部结构:修饰属性、方法、构造器、内部类
修饰类的话，只能使用:缺省、public

总结封装性:Java提供了4种权限修饰来修饰类及类的内部结构，体现类及类的内部结构在调用时的可见性的大小。

public class AnimalTest {
    public static void main(String[] args) {
        Animal a=new Animal();
        a.name="花花";
        a.age=1;
        //a.legs=4;  不可见

        a.show();

        //a.legs=-4; 不可见
//        a.setLegs(6);
        a.setLegs(-6);
        a.show();
    }
}
class Animal{
    String name;
    int age;
    private int legs;//腿的个数


    //属性的获取
    public  int getLegs(){
        return legs;
    }
    //属性的设置
    public void setLegs(int l){
        if (l>=0&&l%2==0){
            legs=l;
        }else {
            legs=0;
            // 抛出一个异常(暂时没讲)
        }
    }

    public void eat(){
        System.out.println("动物进食");
    }
    public void show(){
        System.out.println("name= "+name+",age= "+age+",legs="+legs);
    }

    //提供关于属性age的get和set方法
    public int getAge(){
        return age;
    }
    public void setAge(int a){
        age=a;
    }

}

类的结构之三:构造器(或构造方法、constructor)的使用

construct:建设、建造 construction:CCB constructor:建设者
一、构造的作用:
1.创建对象
2.初始化对象的信息
二、说明:
1.如果没有显式的定义类的构造器的话，则系统会默认提供一个空参的构造器
2.定义构造器的格式:权限修饰符 类名(形参列表){}
3.一个类中定义的多个构造器，彼此构成重载
4.一旦显式的定义了类的构造器之后，系统就不在提供默认的空参构造器
5.一个类中，至少会有一个构造器

public class PersonTest {
    public static void main(String[] args) {
        //创建类的对象:new + 构造器
        Person p =new Person();
        p.eat();

        Person p1=new Person("Tom");
        System.out.println(p1.name);

    }
}
class Person{

    //属性
    String name;
    int age;


    //构造器
    public Person(){
        System.out.println("Person()....");
    }
    public Person(String n){
        name=n;
    }
    public Person(String n,int a){
        name=n;
        age=a;
    }

    //方法
    public void eat(){
        System.out.println("人吃饭");
    }
    public void study(){
        System.out.println("人可以学习");
    }
}

JavaBean是一种Java语言写成的可重用组件
所谓JavaBean,是指符合如下标准的Java类:
>类是公共的
>有一个无参的公共的构造器
>有属性，且有对应的get、set方法

public class Customer {
    private int id;
    private String name;
    public Customer(){

    }
    public void setId(int i){
        id=i;
    }
    public int getId(){
        return id;
    }
    public void setName(String n){
        name=n;
    }
    public String getName(){
        return name;
    }
}

总结:属性赋值的先后顺序
1.默认初始化
2.显示初始化
3.构造器中初始化
4.通过"对象.方法" 或"对象.属性"

以上操作的先后顺序:1->2->3->4

public class UserTest {
    public static void main(String[] args) {
        User u=new User();
        System.out.println(u.age);

        User u1=new User(2);
        u1.setAge(3);
        System.out.println(u1.age);
    }
}
class User{
    String name;
    int age=1;

    public User(){
    }
    public User(int a){
        age=a;
    }
    public void setAge(int a){
        age=a;
    }
}

this关键字的使用:

1.this可以用来修饰、调用:属性、方法、构造器

2.this修饰属性和方法
this理解为:当前对象 或当前正在创建的对象(构造器)
2.1在类的方法中，我们可以使用"this.属性"或者"this.方法"的方式，调用当前对象属性或方法。但是，通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显示的使用"this.变量"的方式，表明此变量是属性，而非形参。
2.2 在类的构造器中，我们可以使用"this.属性"或者"this.方法"的方式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都选择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显示的使用"this.变量"的方式，表明此变量是属性，而非形参。
3.this调用构造器
1、我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其它构造
2、构造器中不能通过"this(形参列表)“方式调用自己
3、如果一个类中有n个构造器，则最多有n-1构造器中使用了"this(形参列表)”
4、规定:"this(形参列表)“必须声明在当前构造器的首行
5、构造器内部:最多只能声明一个"this(形参列表)”，用来调用其它的构造器

public class thisTset {
    public static void main(String[] args) {
        ThisPerson t=new ThisPerson();
        t.setAge(1);
        System.out.println(t.getAge());
        t.eat();
        System.out.println();
        ThisPerson t2=new ThisPerson("Jerry",20);
        System.out.println(t2.getAge());
    }
}
class  ThisPerson{

    //属性
    private String name;
    private int age;

    //构造器
    public ThisPerson(){
        this.eat();
        //ThisPerson初始化时，需要考虑如下的1，2，3，4...(共40行代码)
        String info="ThisPerson初始化时，需要考虑如下的1，2，3，4...(共40行代码)";
        System.out.println(info);
    }
    public ThisPerson(String name){
        this();
        //this 当前正在创建的对象
        this.name=name;
    }
    public ThisPerson(int age){
        this();
        this.age=age;
        // this();
    }
    public ThisPerson(String name,int age){
        this(age);
        this.name=name;
        //this.age=age;
    }

    //方法
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return this.name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return this.age;
    }

    public void eat(){
        System.out.println("eat");
        this.study();
    }
    public void study(){
        System.out.println("study");
    }
}

一、package关键字的使用
1.为了更好的实现项目中类的管理，提供包的概念
2.使用package声明类或接口所属的包，声明在源文件的首行
3.包，属于标识符，遵循标识符的命名规则、规范(xxxxyyyyyzzz)、“见名知意”
4.每"."一次，就代表一层文件目录

补充:同一个包下，不能命名相同名的接口、类
不同的包下，可以命名相同名的接口、类

二、import关键字的使用
import:导入
1.在源文件中显示的使用import结构导入指定包下的类、接口
2.声明在包的声明和类的声明之间
3.如果需要导入多个结构，则并列写出即可
4.可以使用"xxx."的方式，表示可以导入xxx包下所有结构
5.如果使用的类或接口是java.lang包下定义，则可以省略import结构
6.如果使用的类或接口是本包下定义，则可以省略import结构
7.如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。
8.如果使用"xxx."方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx包下的结构，则仍需要显式的导入

9.import static:导入指定类或者接口中的静态结构:属性或者方法。

面对对象的特征之二:继承性

一、继承性的好处:
1.减少了代码的冗余，提高了代码的复用性
2.便于功能的扩展
3.为之后多态的使用，提供了前提
二、继承性的格式:class A extends B{}
A:子类、派生类、subclass
B:父类、超类、几类、superclass
2.1体现:一旦子类A继承父类B以后,子类A中就获取了父类B中声明的结构:属性、方法
特别的:父类中声明为private的属性或方法，子类继承父类以，仍然认为获取了父类中私有的结构，只因为封装性的影响，使得子类不能直接调用父类的结构而已。
2.2子类继承父类以后，还可以声明自己特有的属性和方法，实现功能的拓展子类和父类的关系，不同于集合和集合的关系。
extends:延展、拓展
三、java中关于继承的规定:
1.一个类可以被多个子类继承
2.java中类的单继承性:一个类只能有一个父类
3.子父类是相对的概念。
4.子类直接继承的父类，称为:直接父类。间接继承的父类称为:简介父类
5.子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法

四、
1.如果我们没用显式的声明一个类的父类的话，则此类继承于java.lang.Object类
2.所有的java类(除了java.lang.Object类除外)都直接或者间接的继承于java.lang.Object类
3.意味着,所有的java类具有java.lang.Object类声明的功能

方法的重写(override/overwrite)

1.重写:子类继承父类以后,可以对父类种同名同参数的方法，进行覆盖操作

2.应用:重写以后，当创建子类对象以后，通过子类对象调用父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。

3.重写的规定:
方法的声明:权限修饰符 返回值类型 方法名(形参列表)throws 异常的类型{
//方法体
}
约定俗称:子类中叫重写的方法，父类中叫被重写的方法
1.子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
2.子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
>特殊情况:子类不能重写父类中声明为private权限的方法
3.返回值类型:
>父类被重写的方法返回值类型是void,则子类重写的方法的返回值类型只能是void
>父类被重写的方法返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
>父类被重写的方法返回值类型是基本数据类型(比如:double),则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)
4.子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型(具体放到异常处理的时候讲)
注:子类和父类中同名同参数的方法要么都声明为非static的(考虑重写),要么都声明为static的(不是重写)。
面试题:区分方法的重载与重写

public class Person {
    String name;
    int age;
    int id=1001;//身份证号

    public Person(){
        System.out.println("我无处不在");
    }
    public Person(String name){
        this.name=name;
    }
    public Person(String name,int age){
       //this.name=name;
        this(name);
        this.age=age;
    }
    public void eat(){
        System.out.println("吃饭");
    }
    public void walk(int distance){
        System.out.println("走路,走的距离是: "+distance+"公里");
        this.show();
    }
    private void show(){
        System.out.println("父");
        System.out.println(name);
    }

    public Object info(){
        return null;
    }

    public double info1(){
        return 1.0;
    }
}

public class Student extends Person{
    String major;
    int id=1002;//学号
    public  Student(){
        super();
    }
    public Student(String major){
        super();
        this.major=major;
    }
    public Student(String name,int age,String major){
//        this.name=name;
//        this.age=age;
        super(name,age);
        this.major=major;
    }
    public void study(){
        System.out.println("学习，专业是: "+major);
        this.eat();
        super.eat();
    }

    //对父类种的eat()进行重写
    public void eat(){
        System.out.println("学生应该多吃有营养的食物");
    }

    public void show(){
        System.out.println("子");
        System.out.println("name = "+this.name +",age= "+super.name);
        System.out.println("id= "+this.id);
        System.out.println("id= "+super.id);

    }

    public String info(){
        return null;
    }

//    public int info1(){
//        return 1;
//    }
}

public class PersonTest {
    public static void main(String[] args) {
        Student s=new Student("计科");
        s.eat();
        s.walk(10);
        s.study();
        System.out.println("************************");
        Person p1=new Person();
        p1.eat();
    }
}

super关键字的使用

1.super理解为:父类的
2.super可以用来调用:属性、方法、构造器

3.super的使用
3.1我们可以在子类的方法或构造器中.通过使用"super.属性"或"super.方法"的方式,显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
3.2 特殊情况:当子类和父类中定义了同名的属性时,我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声的属性
3.3特殊情况:当子类重写了父类的方法以后,我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中声明的属性。

4.super调用构造器
4.1我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
4.2"super(形参列表)"的使用，必须声明在子类构造器的首行。
4.3我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)“只能二选一，不能同时出现
4.4在构造器的首行，没用显式的声明"this(形参列表)“或"super(形参列表)”,则默认调用的是父类中空参的构造器:super()
4.5在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)”,调用父类中的构造器

子类对象实例化的全过程

1.从结果上来看:
子类继承父类以后，就获取了父类中声明的属性和方法。
创建子类的对象，在堆空间中，就会加载所有父类中声明的属性。

2.从过程上来看:
当我通过子类的构造器创建子类对象时，我们一定会直接间接的调用父类的构造器，进而调用父类的构造器直到调用了java.lang.Object类中的空参构造器为止，正因为加载过所有的父类结构，所有才可以看到内存中有父类中的结构，子类对象才可以考虑进行调用

明确:虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象

面向对象特征之三:多态性

1.理解多态性:可以理解为一个事物的多种形态
2.何为多态性:
对象的多态性:父类的引用指向子类的对象(或子类的对象赋给父类的引用)
3.多态的使用:虚拟方法调用
有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法

总结:编译，看左边; 运行，看右边
4.多态性的使用前提:1.类的继承关系 2.方法的重写

5.对象的多态性只适用于方法，不适用于属性(编译运行都看左边)

public class Person {
    String name;
    int age;
    int id=1001;


    public void eat(){
        System.out.println("人，吃饭");
    }
    public void walk(){
        System.out.println("人，走路");
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;
        Person person = (Person) o;
        return age == person.age &&
                id == person.id &&
                Objects.equals(name, person.name);
    }
}

public class Woman extends Person {

    boolean isBeauty;

    public void goShopping(){
        System.out.println("女人喜欢购物");
    }

    public void eat(){
        System.out.println("女人少吃，为了减肥");
    }
    public void walk(){
        System.out.println("女人窈窕的走路");
    }
}

public class Man extends Person {
    boolean isSmoking;
    int id=1002;

    public void earnMoney(){
        System.out.println("男人负责赚钱养家");
    }
    public void eat(){
        System.out.println("男人多吃肉，长肌肉");
    }

    public void walk(){
        System.out.println("男人霸气的路");
    }
}

public class PersonTest {
    public static void main(String[] args) {
        Person p1=new Person();
        p1.eat();

        Man man =new Man();
        man.eat();
        man.age=25;
        man.earnMoney();

        //*******************************************
        System.out.println("*********************");
        //对象的多态性:父类的引用指向的对象
        Person p2=new Man();
//      Person p3=new Woman();
        //多态的使用:当通过用子父类同名参数的方法时，实际执行的是子类重写父类---虚拟方法调用
        p2.eat();
        p2.walk();

        //不能调用子类所特有的方法、属性，编译时，p2是Person类型
        //p2.earnMoney();
        p2.name="Tom";
        System.out.println(p2.id);//1001

        //有了对象的多态性以后：内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致
        // 编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。

        //如何才能调用子类特有的属性和方法?
        //向下转型:使用强制类型转换符
        Man m1=(Man)p2;
        m1.earnMoney();
        m1.isSmoking=true;

        //使用强转时，可能出现ClassCastException的异常
//        Woman w1=(Woman)p2;
//        w1.goShopping();
        /**
         * instanceof
         *
         * a instanceof A:判断对象是否是类A的对象实例。如果是，返回true,如果不是，返回false
         *
         * 使用情境:为了避免在向下转型CLassCastException的异常，我们在向下转型之前，
         * 先进行instanceof的判断，一旦返回true,就进行向下转型。如果返回false,不进行向下转型。
         *
         * 如果 a instanceof A返回true,则a instanceof B也返回true
         * 其中，类B是类A的父类。
         *
         */
        if (p2 instanceof Woman){
            Woman w1=(Woman)p2;
            w1.goShopping();
            System.out.println("*************Woman**************");
        }
        if (p2 instanceof Man){
            Man m2=(Man)p2;
            m2.earnMoney();
            System.out.println("*************Man**************");
        }
        if (p2 instanceof Person){
            System.out.println("*************Person**************");
        }
        if (p2 instanceof Object){
            System.out.println("*************Object**************");
        }


        //练习:
        //问题一:编译时通过，运行时不通过
        //举例一:
//        Person p3=new Woman();
//        Man m3=(Man)p3;
        //举例二:
//        Person p4=new Person();
//        Man m4=(Man)p4;

        //问题二:编译时通过，运行时也通过
        Object obj=new Woman();
        Person p=(Person)obj;

        //问题三:编译不通过
//        Man m5=new Woman();

//        String str=new Data();


    }
}

== 和equal() 的区别

一、回顾==的使用
1，可以使用在基本数据类型变量和引用数据类型变量中
2.如果比较的是基本数据类型变量:比较两个变量保存的数据是否相等。(不一定类型要相同)
如果比较的是引用数据类型变量:比较两个对象的地址值是否相同，即两个引用是否指向同一个对象实体

补充:==符号使用时，必须保证符号左右两边的变量类型一致

二、equals()方法的使用:
1.是一个方法，而非运算符
2.只适用于引用数据类型
3.Object类中equals()的定义:

public boolean equals(Object obj){
          return (this==obj)
      }

说明:Object类中定义的equals()和==的作用是相同，比较两个对象地址值是否相同，即两个引用是否指向同一个对象

4.像String、Data、File、包装类等都重写了Object类中的equals()方法，重写以后，
比较的不是两个引用的地址值，而是比较两个对象的"实体内容"是否相同

5.通常情况下，我们自定义的类如果适用equals()的话，也通常是比较两个对象的"实体内容"是否相同,
那么，我们就需要对Objects类中的equals()进行重写

重写的规则:比较两个对象的内容是否相同

public class EqualTset {
    public static void main(String[] args) {
        int i=10;
        int j=10;
        double d=10.0;
        System.out.println(i==j);
        System.out.println(i==d);
        if ("1".equals("1")){}
    }
}

Object类中toString()的使用:

1.当我们输出一个对象的引用时，实际上调用的是当前对象的toString()

2.Object类中toString()的定义:

public String toString() {
          return getClass().getName() + "@" + Integer.toHexString(hashCode());
      }

3.String、Date、File、包装类等都重写了Object类中toString()方法。
使得在调用对象的toString()时，返回"实体内容"信息。

4.自定义类也可以重写toString()方法，当调用此方法时，返回对象的"实体内容"

public class Person {
    String name;
     private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Person(){

    }
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }

    public void eat(){
        System.out.println("吃饭");
    }

    public void sleep(){
        System.out.println("睡觉");
    }
	
@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof Person)) return false;
    Person person = (Person) o;
    return age == person.age &&
            Objects.equals(name, person.name);
}
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class ToStringTest {
public static void main(String[] args) {
        Person person=new Person("Tom",21);
        System.out.println(person.toString());//com.day10.Person@1540e19d
        System.out.println(person);//com.day10.Person@1540e19d

        String str=new String("MM");
        System.out.println(str);//MM

        Date date=new Date(21321321312L);
        System.out.println(date.toString());
    }
}

java.lang.Object类

1.Object类是所有java类的根父类
2.如果在类的声明中使用的extends关键字指明其父类，则默认父类为java.lang.Object类
3.Object类中的功能(属性、方法)就具有通用性。
属性;无
方法: equals() /toString() /getClass /hashCode()/ clone() /finalize()
wait() /notify() /notifyAll()

4.Object类只声明了一个空参构造器+

面试题:
final、finally、finalize的区别

java中的JUnit单元测试

步骤:
2,创建java类，进行单元测试。
此时的java类要求:1、此类是public的 2、此类提供公共的无参的构造器 3.此类中声明单元测试方法。
此时的单元测试方法:方法的权限是public,没有返回值，没有形参
4,此单元测试方法上需要声明注解:@Test,并在单元测试类中导入:import org.junit.Test
5.声明好单元测试方法以后，就可以在方法体内测试相关的代码。
说明:
1.如果执行结果没有任何异常:绿条
2.如果执行结果出现异常:红条

public class JUnitTest {
    int num=10;
    @Test
    public void testEquals(){
        String s1="MM";
        String s2="MM";
        System.out.println(s1.equals(s2));

        System.out.println(num);
        show();
    }

    public void show(){
        num = 20;
        System.out.println("----");
    }

    @Test
    public void testToString(){
        String s2="MMMM";
        System.out.println(s2.toString());
    }
}

包装类的使用:

1.java提供了8种基本类型对应的包装类，使得基本数据类型的变量具有类的特征

2.掌握的:基本数据类型、包装类、String三者之间的转换

public class WrapperTest {
    //String类型--->基本数据类型、包装类:调用包装类的parseXxx()
    @Test
    public void test5(){
        String str1="123";
//        int num1=(int)str1;
//        Integer in1=(Integer)str1;
        int num2 = Integer.parseInt(str1);
        System.out.println(num2+1);
    }
    //基本数据类型、包装类--->String类型，调用String重载的valueOF(Xxx xxx)
    @Test
    public void test4(){
        int num1=10;
        //方式1:连接运算
        String str1=num1+"";
        //方式二:调用String重载的valueOF(Xxx xxx)
        float f1=12.3f;
        String str2 = String.valueOf(f1);//"12.3"

        Double d1=new Double(12.4);
        String str3 = String.valueOf(d1);
        System.out.println(str3);

    }

    /**
     * JDK 5.0新特性：自动装箱与自动拆箱
     */
    @Test
    public void test3(){
//        int num1=10;
//        //基本数据类型-->包装类的对象
//        method(num1);

        //自动装箱:基本数据类型---->包装类
        int num2=10;
        Integer in1=num2;//自动装箱

        //自动拆箱:包装类---->基本数据类型
        System.out.println(in1.toString());

        int num3=in1;

    }

    public void method(Object obj){

    }
    //包装类---->基本数据类型:调用包装类的xxxValue()
    @Test
    public void test2(){
        Integer in1=new Integer(12);
        int i1 = in1.intValue();
        System.out.println(i1+1);

        Float f1=new Float(12.3);
        float f2=f1.floatValue();
        System.out.println(f2+1);
    }

    //基本数据类型---->包装类:调用包装类的构造器
    @Test
    public void test1(){
        int num1=10;
        Integer in1=new Integer(num1);

        System.out.println(in1.toString());

        //报异常
//        Integer in2=new Integer("abc"); //"123"才行
//        System.out.println(in2.toString());

        Float f1=new Float(12.3f);
        Float f2=new Float("12.3");
        System.out.println(f1);
        System.out.println(f2);

        Boolean b1=new Boolean(true);
        Boolean b2=new Boolean("tRuE");
        System.out.println(b2);//true
        Boolean b3=new Boolean("true123");
        System.out.println(b3);//false

        Order order=new Order();
        System.out.println(order.isMale);//false
        System.out.println(order.isfemale);//null


    }
    class Order{
        boolean isMale;
        Boolean isfemale;
    }
}