目录
为什么需要封装？封装的作用和含义？
我要用洗衣机，只需要按一下开关和洗涤模式就可以了。有必要了解洗衣机内 部的结构吗？有必要碰电动机吗？
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。
使用者对类内部定义的属性(对象的成员变量)的直接操作会导致数据的错误、混乱或安全性问题。
class Animal {
public int legs;
public void eat(){
System.out.println("Eating");
}
public void move(){
System.out.println("Moving.");
}
}
public class Zoo {
public static void main(String args[]) {
Animal xb = new Animal();
xb.legs = 4;
System.out.println(xb.legs);
xb.eat();
xb.move();
}
}
Java中通过将数据声明为私有的(private)，再提供公共的（public） 方法:getXxx()和setXxx()实现对该属性的操作，以实现下述目的：
class Animal {
private int legs;// 将属性legs定义为private，只能被Animal类内部访问
public void setLegs(int i) { // 在这里定义方法 eat() 和 move()
if (i != 0 && i != 2 && i != 4) {
System.out.println("Wrong number of legs!");
return;
}
legs = i;
}
public int getLegs() {
return legs;
}
}
public class Zoo {
public static void main(String args[]) {
Animal xb = new Animal();
xb.setLegs(4); // xb.setLegs(-1000);
//xb.legs = -1000; // 非法
System.out.println(xb.getLegs());
}
}
对于 class 的权限修饰只可以用 public 和 default( 缺省 ) 。
- public类可以在任意地方被访问。
- default类只可以被同一个包内部的类访问
Order o = new Order(); Person p = new Person(“Peter”,15);
如同我们规定每个“人”一出生就必须先洗澡，我们就可以在“人”的 构造器中加入完成“洗澡”的程序代码，于是每个“人”一出生就会自动完成“洗澡”，程序就不必再在每个人刚出生时一个一个地告诉他们 要“洗澡”了
修饰符 类名 ( 参数列表 ) {初始化语句；}
public class Animal {
private int legs;
// 构造器
public Animal() {
legs = 4;
}
public void setLegs(int i) {
legs = i;
}
public int getLegs() {
return legs;
}
}注 意：
构造器一般用来创建对象的同时初始化对象。
class Person{
String name;
int age;
public Person(String n , int a){ name=n; age=a;}
}public class Person{
public Person(String name, int age, Date d) {this(name,age);…}
public Person(String name, int age) {…}
public Person(String name, Date d) {…}
public Person(){…}
}public class Person { 构造器重载举例
private String name;
private int age;
private Date birthDate;
public Person(String n, int a, Date d) {
name = n;
age = a;
birthDate = d;
}
public Person(String n, int a) {
name = n;
age = a;
}
public Person(String n, Date d) {
name = n;
birthDate = d;
}
public Person(String n)
name = n;
age = 30;
}
}所谓javaBean，是指符合如下标准的Java类：
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以 用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP 页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关 心任何改变。
public class JavaBean {
private String name; // 属性一般定义为private
private int age;
public JavaBean() {
}
public int getAge() {
return age;
}
public void setAge(int a) {
age = a;
}
public String getName() {
return name;
}
public void setName(String n) {
name = n;
}
}
调用属性、方法
class Person{ // 定义Person类
private String name ;
private int age ;
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public void getInfo(){
System.out.println("姓名：" + name) ;
this.speak();
}
public void speak(){
System.out.println(“年龄：” + this.age);
}
}调用本类的构造器
class Person{ // 定义Person类
private String name ;
private int age ;
public Person(){ // 无参构造器
System.out.println("新对象实例化") ;
}
public Person(String name){
this(); // 调用本类中的无参构造器
this.name = name ;
}
public Person(String name,int age){
this(name) ; // 调用有一个参数的构造器
this.age = age;
}
public String getInfo(){
return "姓名：" + name + "，年龄：" + age ;
}
}pack1\pack2\PackageTest.java
package pack1.pack2; //指定类PackageTest属于包pack1.pack2
public class PackageTest{
public void display(){
System.out.println("in method display()");
}
}
/*
① 面向对象的特征一 封装与隐藏
问题的引入
当我们创建一个类的对象以后，我们可以通过 对象.属性的方式，对对象的属性进行赋值
这里的赋值操作要受到 属性的数据类型和存储范围的制约，除此之外没有其他的制约条件
但是，在实际问题中我们往往需要给属性赋值加入额外的限制条件，这个条件不能在属性声明
时体现，我们只能通过方法进行限制条件的添加，同时我们需要避免用户使用对象.属性的方式
对属性进行赋值，则需要将属性声明为私有的（private）
此时针对于属性就体现了封装性（例如：setAge）
②封装性的体现
我们将类得属性xxx私有化（private），同时提供（public）方法来获取和设置此属性值
③封装性的体现需要权限修饰符的配合
java规定了四种权限（从小到大排列） private 缺省 protected public
四种权限可以用来修饰 类及类的内部结构（属性 方法 构造器 内部类）
具体的：四种权限都可以用来修饰类的内部结构
修饰类的话只能使用 缺省 public
private：出了类就私有结构就不能调用了
缺省：出了类所属的包之后 私有结构 && 缺省声明的结构就不能调用了
总结封装性：java提供了四种权限修饰符，来修饰类及类的内部结构，体现及类的内部结构在调用时的可见性
④ 类的结构之三 构造器
constructor：建设，建造（构造者）
构造器的作用：创建对象 初始化对象的的信息
说明
1.如果没有显示的定义类的构造器的话，则系统默认提供一个空参的构造器
2.定义构造器的格式:权限修饰符 类名（形参列表）{}
3.一个类中定义多个构造器彼此构成重载
4.一但显示的定义了类的构造器之后，系统就不在提供默认的空参构造器
5.一个类中至少有一个构造器
⑤ 总结属性赋值的先后顺序
1.默认初始化值
2.显示初始化
3.构造器中赋值
4. 通过 对象.属性 或对象.方法赋值
以上操作的先后顺序 1 2 3 4
⑥JavaBean
JavaBean是一种Java语言写成的可重用组件。
类是公共的
有一个无参的公共的构造器
有属性，且有对应的get、set方法
⑦ this关键字的使用
this可以用来修饰 属性 方法 构造器
this修饰属性和方法
this理解为当前对象 或 当前正在创建的对象
在类的方法或构造器中我们可以使用 this.属性或者this.方法的方式，调用当前对象的属性或方法
但是通常情况下都省略this. 如果方法的形参和类的属性同名时，我们必须显示的使用
this.变量的方式 表示是变量属性，而非形参
this调用构造器
1.我们在类的构造器中可以显示的使用 this（形参列表）的方式调用本类中指定的其他构造器
2.构造器不能this（形参列表）的方式调用自己
3.如果一个类中有n个构造器则最多有n-1构造器中使用了this（形参列表）
4.规定this（形参列表） 必须声明在当前构造器的首行
5.构造器内部最多只能声明一个this（形参列表，用来调用其他构造器
⑧ package关键字的使用
为了更好的实际项目的管理，提供包的概念
使用package声明包或者接口 声明在源文件的首行
包属于标识符 遵循标识名命名规则
每.一次代表一次文件目录
同一个包下不能 命名同名的接口或者类（不同的包下可以）
⑨ import关键字的使用
import导入
1.源文件中显示的使用inport 导入指定包下的类 接口
2.声明在包的声明 和类的声明之间
3.如果需要导入多个包，则并列写出即可
4.可以使用“xxx*”的方式导入xxx包下的所有结构
5.如果使用的java.lang包下定义的 则可以省略import结构
6.如果声明的类或者接口是本包下定义的也可以省略
7.如果在源文件中使用了不同包下同名的类，则必须至少有一个全类名的方式显示
8. 如果使用 “xxx*”方式表明可以调用xxx包下所有的结构，但是使用的是xxx子包下的结构扔需要显示导入
9. import static 导入类或接口中静态结构 属性或方法
*/
class animalTest {
public static void main(String[] args) {
//创建类的对象 new+构造器
Animal a=new Animal();
a.name="Tom";
//a.age=1; age可以在Animal中访问private
a.legs=4;
a.show();
a.setAge(-4);
a.show();
Animal a1=new Animal("zs");
System.out.println(a1.name);
Animal a2=new Animal("zs");
a2.setName("ls");
System.out.println(a2.name);
}
}
class Animal{
String name;
private int age;
int legs;
//构造器
public Animal(){
System.out.println("Animal.....");
}
public Animal( String n){
this();
name=n;
}
//设置值
public void setAge(int a){
if(a>=0){
age=a;
}else{
age=0;
}
}
//查看值
public int getAge(){
return age;
}
public void show(){
System.out.println("name="+name+",age="+age+",legs="+legs);
}
//this
public void setName(String name){
this.name=name;
}
}