java面向对象----封装 && 构造器

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

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

• 类是公共的
• 有一个无参的公共的构造器
• 有属性，且有对应的get、set方法

 用户可以使用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;
    }
}

UML类图

• 1. + 表示 public 类型， - 表示 private 类型，#表示protected类型
• 2. 方法的写法: 方法的类型(+、-) 方法名(参数名： 参数类型)：返回值类型

关键字—this

this是什么？

•  它在方法内部使用，即这个方法所属对象的引用；
•  它在构造器内部使用，表示该构造器正在初始化的对象。
•  this 可以调用类的属性、方法和构造器

•  当在方法内需要用到调用该方法的对象时，就用this。
• 具体的：我们可以用this来区分属性和局部变量。
• 比如：this.name = name;

 使用this，调用属性、方法  构造器

调用属性、方法 

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 ;
    } 
}

• 1. 在任意方法或构造器内，如果使用当前类的成员变量或成 员方法可以在其前面添加this， 增强程序的阅读性。不过，通 常我们都习惯省略this。
• 2. 当形参与成员变量同名时， 如果在方法内或构造器内需要使用成员变量，必须添加this来表明该变量是类的成员变量
• 3.使用this访问属性和方法时，如果在本类中未找到，会从父类中查找
• 4.this 可以作为一个类中 构造器相互调用的特殊格式
• 当前正在操作本方法的对 象称为当前对象。

 

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

• 1. 在源文件中使用import显式的导入指定包下的类或接口
• 2. 声明在包的声明和类的声明之间。
• 3. 如果需要导入多个类或接口，那么就并列显式多个import语句即可
• 4. 举例：可以使用java.util.*的方式，一次性导入util包下所有的类或接口。
• 5. 如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
• 6. 如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的 是哪个类。
• 7. 如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。
• 8. import static组合的使用：调用指定类或接口下的静态的属性或方法

总结

/*
① 面向对象的特征一 封装与隐藏
问题的引入
	当我们创建一个类的对象以后，我们可以通过 对象.属性的方式，对对象的属性进行赋值
	这里的赋值操作要受到 属性的数据类型和存储范围的制约，除此之外没有其他的制约条件
	但是，在实际问题中我们往往需要给属性赋值加入额外的限制条件，这个条件不能在属性声明
	时体现，我们只能通过方法进行限制条件的添加，同时我们需要避免用户使用对象.属性的方式
	对属性进行赋值，则需要将属性声明为私有的（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;
	
	}
}