java基础~面向对象之封装

目录

封装的引入：

封装性的体现：

权限修饰符：

封装性练习

构造器（构造方法）

属性赋值的先后顺序：

JavaBean

关键字：this的使用

---

封装的引入：

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

例：

public class AnimalTest {
	public static void main(String[] args) {
		
		Animal a = new Animal();
//		a.legs = 4;//会报错，因为权限修饰符private定义的是私有属性
	

//通过调用方法对属性赋值
//		a.setLegs(6);//6
		a.setLegs(-6);//0	
	}
}

class Animal{
	//int legs；腿的个数
	private int legs;//加上private权限修饰词会让legs变成私有属性，在类外部不能直接调用，可以通过setLegs()进行调用赋值
	
	//因为legs属性代表腿的个数所以要对legs的值进行限制
	//对legs属性的设置
	public void setLegs(int l){
		if(l >= 0 && l % 2 == 0){
			legs = l;
		}else{
			legs = 0;
//			抛出一个异常（暂时没有讲）
		}
	}

封装性的体现：

1. 我们将类的属性xxx私有化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值

2. 不对外暴露的私有的方法

3. 单例模式

例：

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

权限修饰符：

• Java规定的4种权限（从小到大排列）：private、缺省、protected 、public

• 4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类

• 4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类

• 修饰类的话，只能使用：缺省、public

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

封装性练习

1.创建程序,在其中定义两个类：Person和PersonTest类。定义如下：用setAge()设置人的合法年龄(0~130)，用getAge()返回人的年龄。

public  class Person{
	private int age；
    
    public int setAge(int i){
      if(age>130||age<0){
        System.out.println("输入的年龄有误！")
        return;//return具有结束方法的作用,没有else必须有return，有else就没有return。
      }
        age=i;
     
    }
    public int getAge(){
       return age;
    }
}

//在同一个包不在同一个类里
public class PersonTest {
	public static void main(String[] args) {
		
		Person p1 = new Person();
//		p1.age = 1;编译不通过
		
		p1.setAge(12);
		
		System.out.println("年龄为：" + p1.getAge());
		
	}
}

构造器（构造方法）

类的结构之三：构造器（或构造方法、constructor）的使用

construct：建设、建造。 construction:CCB constructor:建设者

一、构造器的作用：

• 1.创建对象

	//创建类的对象:new + 构造器
	Person p = new Person();
	//如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器，这个构造器是在所定义的类中
	public Person(){
		//构造器
	}

• 2.初始化对象的信息

public class PersonTest {
	public static void main(String[] args) {
		//创建类的对象:new + 构造器
		Person p1 = new Person("Tom");	
		//创建对象的时候，对象里的name属性已经初始化，值为Tom
		System.out.println(p1.name);
	}
}
  class Person{
      //初始化对象的信息，在创建对象的同时对对象的属性进行初始化
      public Person(String n){
          name = n;
      }
  }

二、说明：

• 如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器，构造器不是方法

• 定义构造器的格式：

//在所在类中定义构造器
//构造器与方法不同，不能没有，如果没有系统默认提供一个空参的构造器
权限修饰符  类名(形参列表){

	}

• 一个类中定义的多个构造器，彼此构成重载

• 一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器

• 一个类中，至少会有一个构造器。

练习：

1. 在前面定义的Person类中添加构造器，利用构造器设置所有人的age属性初始值都为18。

public class PersonTest {
	public static void main(String[] args) {
		
		Person p1 = new Person();
		System.out.println("年龄为：" + p1.getAge());
	}
}
public class Person {
	
	private int age;
	public Person(){
		age = 18;
	}
	public int getAge(){
		return age;
	}

2.修改上题中类和构造器，增加name属性,使得每次创建Person对象的同时初始化对象的age属性值和name属性值。

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

		System.out.println("name = " + p1.getName() + ",age = " + p1.getAge());
	}
}

 class Person {
	 
	private String name;
	private int age;
	public Person(){
		age = 18;
		name = "zhang";
	}
	public int getAge(){
		return age;
	}

	public String getName(){
		return name;
	}
	
}

3.编写两个类，TriAngle和TriAngleTest，其中TriAngle类中声明私有的底边长base和高height，同时声明公共方法访问私有变量。此外，提供类必要的构造器。另一个类中使用这些公共方法，计算三角形的面积。

public class TriAngleTest {
	public static void main(String[] args) {
		
		TriAngle t1 = new TriAngle();
		t1.setBase(2.0);
		t1.setHeight(2.4);
//		t1.base = 2.5;//内存里存在base变量，因为是private私有属性不能直接访问
//		t1.height = 4.3;//内存里存在height变量，因为是private私有属性不能直接访问
		System.out.println("base : " + t1.getBase() + ",height : " + t1.getHeight());
		
		TriAngle t2 = new TriAngle(5.1,5.6);//构造器重载
		System.out.println("base : " + t2.getBase() + ",height : " + t2.getHeight());
	}
}



public class TriAngle { //angle:角    angel:天使
	
	private double base;//底边长
	private double height;//高
	
	public TriAngle(){
		
	}
	
	public TriAngle(double b,double h){
		base = b;
		height = h;
	}
	
	
	public void setBase(double b){
		base = b;
	}
	public double getBase(){
		return base;
	}
	public void setHeight(double h){
		height = h;
	}
	public double getHeight(){
		return height;
	}
	
}

属性赋值的先后顺序：

顺序：1~2~3~4

1. 默认初始化

   在创建对象的时候，会有默认初始化值

   • 整型（byte、short、int、long）：0

   • 浮点型（float、double）：0.0

   • 字符型（char）：ASCII码值为 0的 char型元素，或'\u0000'，而非数字"0"

   • 布尔型（boolean）：false

   • 引用数据类型（类、数组、接口）：null

2. 显示初始化/在代码块中赋值

   在类中定义属性的时候赋值

   例：

class User{
	int a = 2;
}

         在代码块中赋值

//非静态代码块
{
    int a = 2;
}

//静态代码块
static{
    int a = 2;
}

    3.构造器初始化

在类的构造器中定义属性的值

例：

public User(int a){
 	a = 2;
}

    4.通过“对象.方法”或“对象.属性”的方式赋值

public class UserTest {
	public static void main(String[] args) {

		User u1 = new User(2);		
		u1.setAge(3);//通过对象.方法赋值
		System.out.println(u1.age);
	}
}

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

JavaBean

JavaBean是一种Java语言写成的可重用组件。

所谓JavaBean，是指符合如下标准的Java类：

• 类是公共的

• 有一个无参的公共的构造器

• 有属性，且有对应的get、set方法

例：

public class Customer {
	
	private int id;
	private String name;
	
	//构造器格式
	权限修饰符  类名(形参列表){
	
	}
	public Customer(){
		
	}
	public Customer(int id){
		this.id = id;
	}
	public Customer(String name){
		this.name = name;
	}
	public Customer(int id,String name){
		this.id = id;
		this.name = name;
	}
    //自动生成构造器：Source--Generate Constructor using Fields
    
     //自动生成get/set方法：Source--Generate Getters and Setters
	public void setId(int id){
		this.id = id;
	}
	public int getId(){
		return id;
	}
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	
}

注：用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

• get/set()方法的作用：

为实现封装性和保证数据的安全性，常将类的成员变量声明为private,再通过set()方法和get()方法或者构造函数方法以public权限修饰词对这个变量进行调用和访问。

public String getName(){
	//访问当前对象的属性
	return this.name;
}

public void setName(String name){
	//给当前对象的属性赋值
	this.name = name;	

}

• get/set()方法命名：

一般JavaBean属性以小写字母开头，驼峰命名格式，相应的 get/set 方法是 get/set 接上首字母大写的属性名。

例如：属性名为userName，其对应的get/set方法是 getUserName/setUserName。

关键字：this的使用

1. this关键字的引入：

下列程序中的Person类中的setName()方法中的n是形参，也是标识符，按照道理来说它的命名应该见名知意，就填写了和Person类中的属性相同的名字，为了区别类的属性和方法的形参，引入this关键字，通俗来讲，this关键字就是代表当前对象，this就是所在函数所属对象的引用，简单来说，哪个对象调用了this所在的函数，this就代表哪个对象。

public class PersonTest {
	public static void main(String[] args) {
		
		Person p1 = new Person();
		p1.setAge(1);
		System.out.println(p1.getAge());	
	}
}
class Person{	

	private String name;
	private int age;
	
  //public void setName(String n){
      //name = n;
  //}
	public void setName(String name){
		this.name = name;//当前对象的age属性 = 形式参数name
	}
	
	public String getName(){
		return name;
	}
	
  //public void setAge(int a){
	  //age = a;
  //}
	public void setAge(int age){
		this.age = age;//当前对象的age属性 = 形式参数age
	}
	
	public int getAge(){
		return age;
	}
	
	public void eat(){
		System.out.println("人吃饭");
		//谁调用eat()方法，我就调用它的study()方法，通常情况下可以省略this.，因为没有其他方法名冲突
		this.study();//方法内可以调用方法,
	}
	public void study(){
		System.out.println("人学习");
	}
}

this关键字的使用：

• this可以用来修饰、调用：属性、方法、构造器

• this可以修饰属性和方法： this代表当前对象 或 当前正在创建的对象（在构造器里使用this的情况，因为创建构造器就是创建对象）

   //见this关键字的引入

  • 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是，通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。

  • 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都选择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。

public Person(){
	private String name;
	private int age;
	
	public Person(){

	}
	
    public Person(String name){
            this.name = name;//当前正在创建的对象的name属性=形式参数name
        }
        
        public Person(int age){
            this.age = age;//当前正在创建的对象的age属性=形式参数age
        }

        public Person(String name,int age){
            this.name = name;//当前正在创建的对象的name属性=形式参数name
            this.age = age;//当前正在创建的对象的age属性=形式参数age
        }
}

this可以调用构造器

在我们想自己设置对象的属性初始化值的时候，我们可以自己创建对象构造器，当我们需要创建多个构造器的时候，构造器也可以构成重载，如果我们想把所有构造器都设置的成自己想设置的对象的属性初始化值的时候，我们可以用"this(构造器参数);"在所在构造器中调用其他构造器。

• 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器

• 构造器中不能通过"this(形参列表)"方式调用自己

• 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)"

• 规定："this(形参列表)"必须声明在当前构造器的首行

• 构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器

class Person{
	
	private String name;
	private int age;
	
	public Person(){
		String info = "Person初始化时，需要考虑如下的1,2,3,4...(共40行代码)";
		System.out.println(info);
	}
	
	public Person(String name){
		this();//调用无参数的构造器
		this.name = name;//当前对象的name属性=形式参数name
		
	}
	
	public Person(int age){
		this();//调用无参数的构造器
		this.age = age;//当前对象的age属性=形式参数age
		
	}
	
	public Person(String name,int age){
		this(age);//调用参数是age的构造器
		this.name = name;//当前对象的name属性=形式参数name
		//this.age = age;因为this(age);所以这句可以注释掉
	}
}

this关键字的练习

Boy类：

public class Boy {
	private String name;
	private int age;
	
	public Boy() {
		
	}
	
	public Boy(String name) {
		this.name = name;
	}

	public Boy(String name, int age) {
		this.name = name;
		this.age = 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 void marry(Girl girl){
		System.out.println("我想娶" + girl.getName());
	}
	
	public void shout(){
		if(this.age >= 22){
			System.out.println("你可以去合法登记结婚了！");
		}else{
			System.out.println("先多谈谈恋爱~~");
		}
		
	}
}

Girl类：

public class Girl {
	
	private String name;
	private int age;
	
	public Girl() {

	}
	public Girl(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void marry(Boy boy){
		System.out.println("我想嫁给" + boy.getName());
		boy.marry(this);//谁调用marry()方法，this就代表当前这个对象。
		//boy对象那边的marry方法传入的是girl，所以this不用调用属性。
	}
		public int compare(Girl girl){
		if(this.age > girl.age){
			return 1;
		}else if(this.age < girl.age){
			return -1;
		}else{
			return 0;
		}
}

测试类：

public class BoyGirlTest {
	public static void main(String[] args) {
		
		Boy boy = new Boy("罗密欧", 21);
		boy.shout();
		
		Girl girl = new Girl("朱丽叶", 18);
		girl.marry(boy);
		
		Girl girl1 = new Girl("祝英台",19);
		int compare = girl.compare(girl1);
		//第一个创建的girl对象调用方法compare(),参数是第二个创建的对象girl1
		//进入compare()方法，如下，this.age是girl对象的age属性的值，girl.age是参数girl1对象的age属性值
//		public int compare(Girl girl){
//			if(this.age > girl.age){
//				return 1;
//			}else if(this.age < girl.age){
//				return -1;
//			}else{
//				return 0;
//			}
//
//			
//		}
		if(compare > 0){
			System.out.println(girl.getName() + "大");
		}else if(compare < 0){
			System.out.println(girl1.getName() + "大");
		}else{
			System.out.println("一样大");
		}
		
	}
}

Package,Import关键字

一、package关键字的使用：

• 为了更好的实现项目中类的管理，提供包的概念

• 2.使用package声明类或接口所属的包，声明在源文件的首行

• 3.包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”

• 4.每"."一次，就代表一层文件目录。

注：同一个包下，不能命名同名的接口、类。

不同的包下，可以命名同名的接口、类。

包的作用：

• 包帮助管理大型软件 系统 ：将功能 相近的类划分到同一个包中 比如 ：MVC MVC的设计模式

 

• 包可以含类和 子包 ，划分项目 层次 ，便于管理

• 解决类命名冲突的问题

• 控制访问权限

JDK中常用包：

1. java.lang----包含一些Java语言的核心类，如String、Math、Integer、 System和Thread，提供常用功能

2. java.net----包含执行与网络相关的操作的类和接口。

3. java.io ----包含能提供多种输入/输出功能的类。

4. java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。

5. java.text----包含了一些java格式化相关的类

6. java.sql----包含了java进行JDBC数据库编程的相关类/接口

7. java.awt----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。 B/S C/S

二、import关键字的使用：import:导入

• 在源文件中显式的使用import结构导入指定包下的类、接口
• 声明在包的声明和类的声明之间
• 如果需要导入多个结构，则并列写出即可
• 可以使用"xxx.*"的方式，表示可以导入xxx包下的所有结构
• 如果使用的类或接口是java.lang包下定义的，则可以省略import结构，因为java.lang是核心包。
• 如果使用的类或接口是本包下定义的，则可以省略import结构
• 如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。

import com.atguigu.exer4.Account;

public class PackageImportTest {
	public static void main(String[] args) {

	  //调用的是com.atguigu.exer4包里的Acount
      Account acct = new Account(1000);

      //我想调用com.atguigu.exer3包里的Acount
      //所以要用全类名的方式显示
      com.atguigu.exer3.Account acct1 = new com.atguigu.exer3.Account(1000,2000,0.0123);

}

• import static:导入指定类或接口中的静态结构:属性或方法。
• 使用"xxx.*"方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入；就是在包下又创建子包，你要调用这个包的子包的方法，还是要Import的。