黑马程序员_day07_封装

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

封装：是指隐藏对象的属性和实现细节，仅对外提供公共的访问方式。

好处：将变化隔离。便于使用。提高重用性。提高安全性。

封装原则：将不需要对外提供的内容都隐藏起来。把属性都隐藏，提供公共方法对其访问。

Private：关键字，权限修饰，用于修饰成员（成员变量，成员函数），私有化的数据只在本类中有效。其他程序创建的对象是无法直接访问的。但是为了便于其他类对其访问，可以对外提供一些公共方法来完成。例：

class Person

{

private int age;//只在本类中有效，不能被其他对象直接访问了

public void setAge(int age)//提供了对外的公共方法

{

this.age=age;

System.out.println(this.age);

}

}

class Demo

{

public static void main(String[] args)

{

Person p=new Person();

p.setAge(12);

}

}

这里setAge： 方法名和变量名写法规范：一个单词组成的名称，所用的字母小写。多个单词的话，第一个单词都是小写，从第二个开始，每个单词的首字母都大写。

通常情况下，会将类中的成员变量私有化，为了避免属性直接被访问导致数据错误，对外提供了公共的访问方式，对该属性进行访问。好处：对属性进行可控。对属性访问的公共方法名称定义格式：set属性（）、get属性（）。若对象中有10个属性，一般则至少有20个方法，因为每个属性通常都对应两个方法：set属性（）；get属性（）

注意：私有仅仅是封装的一种体现形式之一。

函数就是一个最小的封装体。类本身也是一种封装。

二、构造函数

特点：1、函数名与类名相同。2、不用定义返回值类型。3、没有具体的返回值。

创建的每个对象都是一个实体，而每个实体都必须要进行初始化后才可以使用。构造函数的作用就是给对象初始化。

任何用class定义的类中，都有一个默认的空参数的构造函数。用于给该类对象进行初始化。如果该类中指定了具体的构造函数，那么默认的构造函数就没有了。

构造函数和一般函数的区别：

1、书写格式不同。2、运行上的不同。构造函数是在对象创建时就被调用了，而且只执行一次。一般函数是在对象创建完后，所需时才会被调用，可以被调用多次。

构造函数是有return语句的，用于结束构造函数的初始化动作。

当一个类中存在多个构造函数时，它们的存在形式是重载。

多个构造函数意味着多种初始化方式，这就要根据对象创建时的参数列表来找到与之对应的初始化方式。比如：

class Person

{

private String name;

private int age;

Person(int age)//构造函数1

{

this.age=age;

}

Person(String name,int age)//构造函数2

{

this.name=name;

this.age=age;

}

}

class Demo

{

public static void main(String[] args)

{

Person p=new Person("zhangsan",22);//根据参数列表，选择了构造函数2.

Person p=new Person();//是错误的，因为默认的构造函数已经没有了。

}

}

构造函数什么时候用？

当描述事物时，该事物一存在，就具备着一些属性和行为。那么，就将这些内容定义在构造函数中。对象的初始化

new Person("lisi");

new:用于在堆内存中开辟空间的关键字，用于创建对象。

Person：明确要创建Person类的对象，即在指定的目录下找Person.class文件，只要该文件存在就会立刻加载进内存。

"lisi"：创建Person类的对象，需要通过哪个构造函数来进行初始化。这里需要用到一个字符串参数的构造函数。

this关键字

当成员变量和局部变量同名的时候，为了区分，可以使用一个关键字来完成.this.name=name;

this代表的是一个对象，哪个对象调用了this所在函数，this就代表哪个对象（被引用的当前对象）

this 什么时候用？

当定义功能时，功能内部使用了调用该功能的对象，这时就用this来表示。

需求：在Person类中定义一个比较方法，判断是否是同龄人。

明确结果:boolean

明确未知内容：Person（因为是一个任意一个Person对象比较其中的年龄）

class Person

{

private String name;

private int age;

Person(String name,int age)

{

this.name=name;

this.age=age;

}

public boolean compare(Person p)

{

return this.age==p.age;//当前对象this和传入对象p进行年龄的比较。

}

}

class CompareDemo

{

public static void main(String[] args)

{

Person p1=new Person("zhangsan",22);

Person p2=new Person("lisi",22);

boolean b=p1.compare(p2);

System.out.println(b);

}

}

this 表现形式：1、this.name=name;

2、this在对象初始化完毕后，才可以使用。构造函数之间的调用可使用this来完成。后面跟上（），指定具体的实参，即明确要调用的构造函数。

构造函数的调用方式：函数调用本类中构造函数的this语句必须定义在构造函数的第一行语句。因为初始化动作要先完成。

class Person

{

private String name;

private int age;

Person(int age)

{

this.age=age;

}

Person(int age,String name)

{

this(age);对Person（int age）构造函数的调用

this.name=name;

System.out.println(name+":::"+age);

}

}

如果写成

    Person(int age,String name)

{

this.name=name;

this(age);是错误的。

}

局部代码块：控制变量的生命周期。

构造代码块：它可以对所有的对象进行初始化。构造函数是对对应的对象进行初始化。

它们没有任何关键字标识

public static void main(String[] args)

{

{int x=9;}

System.out.println(x);//是错误的。找不到符号x

  }

而构造代码

class Person

{

private String name;

private int age;

{

System.out.println("cry");//这便是构造代码

}

Person(int age)

{

this.age=age;

System.out.println(age);

}

}

class CompareDemo

{

public static void main(String[] args)

{

Person p1=new Person(12);

Person p2=new Person(9);

}

}结果是cry 12 cry 9

三、static（静态）关键字

1、被static修饰的成员变量，被所有的对象所共享。

方法区（共享区）：凡是被对象所共享的数据都在这片区域中。

2、静态随着类的加载而加载，消失而消失。

3、优先于对象存在

4、静态成员可以被直接被类所调用

class Person

{

private int age;

static String country="CN";

}

class Demo

{

public static void main(String[] args)

{

System.out.println(Person.country);直接被类所调用。

}

}

特有数据：存储在对象中的数据。如上述代码中Person类中的age

共享数据：static

Static的使用注意事项：

1、静态方法只能调用静态成员，不能调用非静态成员。

非静态方法可以调用静态成员，也可以调用非静态成员。

2、在静态方法中不允许出现this、super关键字。因为this代表对象，而静态方法执行时还没有对象呢。

静态数据先于非静态数据，所以静态方法不能调用非静态数据。

3、主函数是静态的。静态是有访问局限的，只能调用静态的内容。

静态成员变量和非静态成员变量的区别：

1、非静态成员变量又称为实例（对象）变量。

静态成员变量又称为类变量（可以直接被类名直接调用的变量）

2、非静态成员变量随着对象的创建而存在，消失而消失。

静态成员变量随着类的加载而加载，随着类的消失而消失。

3、非静态成员变量存在于对象的堆内存中。

静态成员变量存在于方法区中。

4、非静态成员变量只能被对象调用

静态成员变量可以被类名调用，也可以被对象调用。

静态什么时候用？

1、成员变量是否需要被static修饰，该成员变量的值是否对每一个对象是相同的。若是，用static修饰，被对象共享。若不是，不用static修饰，让这些存储到每个对象中。

2、成员函数是否被静态修饰？当函数中访问到了对象的特有属性时，该函数不能被静态所修饰。简单说，就是如果函数中访问了成员变量（实例变量）就不能静态修饰了。否则可以静态化。

如果一个类中定义的方法都是静态的，说明这个类是不需要对象的。所以在本类中，加入一些强制措施：private 类名（）{}即将构造函数私有化，这样其他程序就无法创建该类的对象了。

静态代码块：

static

{

code----

}

特点：随着类的加载而执行，且只执行一次。

优先于主函数执行。

作用：给类初始化。示例如下：

class Person

{

static

{

System.out.println("fuck");//静态代码块

}

private int age;

static String country="CN";

}

class Demo

{

public static void main(String[] args)

{

System.out.println(Person.country);

}

}结果是 fuck  CN

栈内存是方法的运行区而非存储区。

调用成员的两种方式：1、用类名调用，但前提是被调用的成员须是静态的。2、用对象来调用。看看下面的小例子们：

1、class Demo

{

int x=6;

public static void main(String[] args)

{

System.out.println("x="+new Demo().x);

}

}若没有下划线部分，就相当于在静态的主函数方法里调用了非静态的x变量，编译报错找不到符号x。这里的下划线部分就是用Demo对象来调用的。因为Demo对象里有x变量。或者不添加下滑线部分，将非静态变量x前加static修饰变为静态成员变量可被静态方法调用。

2、class  Demo

{

 int x=6;

public static void main(String[] args) 

{  

new Demo().show();

}

public void show()

{

System.out.println("x="+x);

}

}通过对象调用的方式。new Demo（）创建的对象实体中既有了所要调用的函数show（）也有了实例成员变量x。若把int x=6;移到main函数中，意味着Demo对象实体中就没有了实例变量x，则会编译报错找不到符号x。

3、class Person

{

static int x=2;

}

class Demo

{

public static void main(String[] args)

{

System.out.println(Person.x);

}这里便是通过类名直接调用静态的x变量

}

----------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------------------