封装与隐藏
面向对象的特征一:封装与隐藏
一、问题的引入:
当我们创建一个类的对象后,我们可以通过“对象.属性"的方式,对对象的属性进行赋值。这里,赋值操作要受到
属性的数据类型和存储范围的制约。除此之外,没有其他制约条件。但是,在实际问题中,我们往往需要给属性赋值
加入额外限制条件。这个条件就不能在属性声明时体现。我们只能通过方法进行限制条件的添加。(比如:setLegs())
同时,我们需要避免用户再使用“对象.属性”的方式对属性进行赋值。则需要将属性声明为私有的(private)
—>此时,针对于属性就体现了封装性。
二、封装的体现
我们将类的属性私有化(private),同时,提供公共(public)方法来获取(getXxx)和设置(setXxx)此属性的值。
拓展:封装性的体现: ①如上 ②不对外暴露的私有化方法 ③单例三、封装性的体现,需要权限修饰符来配合
1、Java规定的4种权限(从小到大排列):private、缺省(default)、protected、public
修饰符 类内部 同一个包 不同包的子类 同一个工程
private Yes
(缺省) Yes Yes
protected Yes Yes Yes
public Yes Yes Yes Yes
☆注意:
对于class的权限修饰只可以用public和default(缺省)。
> public类可以在任意地方被访问。
> default类只可以被同一个包内部的类访问。
2、4种权限可以用来修饰类及类的内部结构:属性、方法、构造器(和类的权限一样)、内部类
3、具体的,4种权限都可以用来修饰内的内部结构:属性、方法、构造器(和类的权限一样)、内部类
修饰类的话,只能使用:缺省、public。
总结:Java提供了4种权限修饰符来修饰类及类的内部结构,体现类及类的内部结构在被调用时可见性的大小。
Animal a = new Animal();
a.name = "大黄";
// a.age = 1;
// a.legs = 4;
a.show();
//a.legs = -4;//用户在赋值时,可能出现不合现实或超出整型表数范围 的值!所以需要关闭对象.属性直接赋值的方式!
a.setLegs(6);
a.show();
//a.legs = 10; //此时不能再直接调用legs这个属性。
//--------------------------- 类 -----------------------------------
class Animal{
String name;
private int age;
private int legs;//腿的个数
//对属性的设置
public void setLegs(int l){
if(l>=0 && l%2 == 0){
this.legs = l;
}else{
legs = 0;
//或抛出一个异常。
}
}
//对属性的获取
public int getLegs(){
return legs;
}
//提供age属性的get和set方法
public int getAge(){
return age;
}
public void setAge(int a){
if(a<0){
age = 0;
//或抛出一个异常
}else{
age = a;
}
}
public void show(){
System.out.println("name ="+name+","+"age ="+age+","+"legs ="+legs);
}
public void eat(){
System.out.println("动物进食");
}
}
构造器
类的结构之三:构造器(或构造方法、constructor)的使用
construct:建设,建造。 construction:CCB。 constructor:建设者。
一、构造器的作用:
1、创建对象
2、初始化对象的信息
二、说明:
1、如果没有显示的定义类的构造器的话,则系统默认提供一个空参的构造器。
2、定义构造器的格式:权限修饰符 类名(形参列表){}
3、一个类中定义多个构造器,彼此构成重载。
4、一旦我们显示的定义了类的构造器之后,系统就不再提供默认的空参构造器。
5、一个类中,至少会有一个构造器。
//创建类的对象: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("人可以学习");
}
}
属性赋值的先后顺序
属性赋值的先后顺序
①默认初始化
②显示初始化
③构造器中初始化
④通过“对象.方法”或“对象.属性”的方式赋值
以上操作的先后顺序:①-②-③-④
User u = new User();
//System.out.println(u.age);//0,没有赋值是默认初始化0
System.out.println(u.age);//1,初始化age为1后,显示1,说明②在①后。
User u1 = new User(2);
System.out.println(u1.age);//2,说明③在②的后面。
User u2 = new User(2);
u2.setAge(3);
System.out.println(u2.age);//3,说明④在③的后面。
//--------------------------- 类 ------------------------------
class User{
//属性
String name;
//int age;
int age = 1;
//构造器
public User(){
}
public User(int a){
age = a;
}
public void setAge(int a){
age = a;
}
}
JavaBean
1、JavaBean是一种Java语言写成的可重用组件。
2、所谓javaBean,是指符合如下标准的Java类:
>类是公共的
>有一个无参的公共的构造器
>有属性,且有对应的get、set方法
3、用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包,
并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。
用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能,而不用关心任何改变。
public class Customer{
//属性
private int id; //属性一般定义为private权限
private String name;
//空参构造器
Public Customer(){
}
//setId方法
public void setId(int i){
id = i;
}
//getId方法
public int getId(){
return id;
}
//setName方法
public void setId(String n){
name = n;
}
//getName方法
public String getName(){
return name;
}
}
this关键字
this关键字的使用:
1、this可以用来修饰、调用:属性、方法、构造器
2、this修饰属性和方法:
this理解为:当前对象 或 当前正在创建的对象
2.1在类的方法中,我们可以使用“this.属性”或“this.方法”的方法,调用当前正在创建的对象的属性或方法。但是
通常情况下,我们都选择省略“this.”。特殊情况下,如果方法的形参和类的属性重名时,我们必须
显示的使用“this.变量”的方式,表明此变量是属性,而非形参。
3、this调用构造器
①我们在类的构造器中,可以显示的使用“this(形参列表)”方式,调用本类中指定的其他构造器。
②构造器中不能通过“this(形参列表)”方式调用自己。
③如果一个类中有N个构造器,则最多N-1个构造器中使用了“this(形参列表)” (避免构成循环!且需要至少一个构造器使用super(形参列表)
来调用父类构造器,以实现继承。)
④规定:“this(形参列表)”必须声明在当前构造器的首行。
⑤构造器内部,最多只能声明一个“this(形参列表)”,用来调用其他构造器。
Person2 P = new Person2();
P.setAge(1);
System.out.println(P.getAge());
P.eat();
//--------------------------- 类 ---------------------------------
class Person2{
private String name;
private int age;
public Person2() {
this.eat();
//假设Person2初始化时,需要写40行代码比较冗余,可以封装一个方法在构造器调用,也可以在一个构造器写完后,其他构造器通过this调用。
}
public Person2(String name){
this();//this()表示调用构造器,调动哪个构造器看后面的()里的形参列表区分。
this.name = name;
}
public Person2(int age){
this();
this.age = age;
}
public Person2(String name,int age){
this(age); //此时当前构造器调用了(int age)这个构造器,把自己形参的age赋给了(int age)形参的age,
// 所以执行到(int age)的代码this.age = age时
//也表示当前构造器的形参的age赋给了this.age。所以当前构造器的代码this.age = age就可以省略了。
// this.age = age;
this.name = name;
}
public void setName(String name){
this.name = name;//this.代表当前对象的...
}
// public void setName(String name){
// name = name; //如果不显示加上“this.”就会让age就近原则,等同于形参的age,导致形参的age赋值给形参的age。
// }
public String getName(){
return name;//等同于this.name;省略了this的写法
}
public void setAge(int age){
this.age = age;//this.代表当前对象的...
}
public int getAge(){
return age;//等同于this.age;省略了this的写法
}
public void eat(){
System.out.println("人吃饭");
study();//等同于this.study();省略了this的写法
}
public void study(){
System.out.println("人学习");
}
}
package关键字
1、为了更好的实现项目中的类的管理,提供包的概率
2、使用package声明类或接口所属的包,声明在源文件的首行
3、包属于标识符,遵循标识符的命名规则、规范、“见名知意”
4、每“.”一次,就代表一层文件目录。
补充:同一个包下,不能命名同名的类、接口。
不同包下,可以命名同名的类、接口。
MVC设计模式
MVC是常用的设计模式之一,将整个程序分为三个层次:视图模型层,控制器层,与数据模型层。这种将程序输入输出、数据处理,
以及数据的展示分离开来的设计模式使程序结构变的灵活而且清晰,同时也描述了程序各个对象间的通信方式,降低了程序的耦合性。
模型层 model 主要处理数据
>数据对象封装 model.bean/domain
>数据库操作类 model.dao
>数据库 model.db
视图层 view 显示数据
>相关工具类 view.utils
>自定义view view.ui
控制层 controller 处理业务逻辑
>应用界面相关 controller.activity
>存放fragment controller.fragment
>显示列表的适配器 controller.adapter
>服务相关的 controller.service
>抽取的基类 controller.base
import关键字
import关键字的使用
import:导入
1、在源文件中显示的使用import结构导入指定包下的类、接口。
2、声明在包的声明和类的声明之间。
3、如果需要导入多个结构,则并列写出即可。
4、可以使用“ XXX.* ”的方式,表示可以导入XXX包下同级目录的所有结构。
5、如果使用的类、接口是java.lang包下定义的,则可以省略import结构
6、如果使用的类、接口是本包下定义的,则可以省略import结构
7、如果在源文件中,使用了不同包下的同名的类,则必须至少有一个需要以全类名的方式显示(包含包的完整路径.类名)。
8、使用“ XXX.* ”方式表明可以调用XXX包下的同级目录的所有结构。但是不能调用XXX子包下的结构(因为不同级,参考文件夹),
仍需要显示导入。
9、import static:导入指定类或接口中的静态结构。(属性、方法)