Java面向对象 (二) 封装
- 在Java中,设计类就必须要学会封装
- 所谓封装: 通俗的将就是告诉我们,如何正确的设计对象的属性和方法。
- 封装的原则:对象代表什么,就得封装对应的数据,并提供数据对应的行为。
前面那一篇文章简要的介绍了一下类,这里将带你们写一个封装的类。
完整的类包含以下几点:
1.成员变量
每个类一般都会有几个成员变量:
成员变量有两种:
1.实例成员变量:
是定义在方法外部和类内部的且不被static所修饰的变量.用于描述一个类中包含哪些数据
private String name;
private int age;
private double height;
2.静态成员变量:
static关键字修饰成员变量,简称静态成员变量,又称类变量
1.访问方式:通过类名.静态成员变量名进行访问
2.内存的存储方式:方法区
3.特点:静态的只有一份,且不依赖对象
private static int money;
类中成员变量有一个和局部变量不一样的特点:
1.成员变量有默认值,无需初始化
2.局部变量没有默认值,使用前需要初始化
成员变量一般无需初始化,存在默认值
byte short int long 0
double float 0.0
boolean false
String 等引用类型 null
2.成员方法
方法是一种语法结构,它可以把一段代码封装成一个功能,以便重复调用。
//举个代码案例
public class Demo01 {
//主方法
//方法的编写顺序无所谓
//方法与方法之间是平级关系不能进行嵌套
//方法必须调用才能执行
public static void main(String[] args){
//有参有返回值 用一个返回值类型的变量接收 并填上参数sum(10,20);
int c = sum(10,20);
System.out.println(c);
//无返回值 无参 直接调用 print();
print();
}
//方法 有参有返回值
public static int sum(int a,int b){
int c = a+b;
return c;
}
//无返回值 无参 方法
public static void print(){
for(int i=0;i<5;i++){
System.out.println("Hello world");
}
}
}
//一个类中如果有多个方法时,方法名可以重复,这是方法重载的一个小知识点
方法重载 :同一个类中,出现 名称 相同,但是 形参 不一样,那么这些方法就是重载(与返回值类型无关)
3.构造器
定义在内中,可以用来初始化一个内的对象,并返回对象的地址
//构造器的格式
修饰符 类名(形参列表){
...
}
public class Car {
String name;
double price;
//构造函数
//无参构造器
public Car(){
System.out.println("--无参构造器被调用了--");
}
//有参构造器
public Car(String n,double p){
System.out.println("--有参构造器被调用了--");
name = n;
price = p;
}
}
**注意:**
一旦定义有参数构造器,那么无参构造器就没有了
如果还想用无参构造器需要自己手写一个
4.代码块
//实例代码块几乎不用 静态代码块用的多一点
//下面是代码案例
public class Demo {
public static ArrayList<String> cards = new ArrayList<>();
/**
* 静态代码块: 有static修饰,属于类,与类一起优先加载一次,自动触发执行。
* 作用:可以用于初始化静态资源。(实例资源不行)
* 格式 static{}
*/
static{
String[] sizes = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
String[] colors = {"♥","♠","♦","♣"};
for (int i = 0; i < sizes.length; i++) {
for (int j = 0; j < colors.length; j++) {
String card = sizes[i] + colors[j];
cards.add(card);
}
}
cards.add("小🃏");
cards.add("大🃏");
}
/**
* 构造代码块 也叫 实例代码块
* 每次创建对象,属于对象,调用构造器执行时,都会执行改代码块中的代码,并在构造器执行前执行
* 格式:{}
*/
{
System.out.println("==========实例代码块执行==========");
schoolName = "清华大学";
}
public static void main(String[] args) {
System.out.println("==========main方法执行==========");
System.out.println(schoolName);
System.out.println("新牌:"+cards);
}
}
5.内部类
//匿名内部类:
本质上是一个没有名字的局部内部类,定义在方法中,代码块中,等。
//作用
//方便创建子类对象,最终目的为了简化代码编写。
格式:
new 类|抽象类名|或者接口名(){
重写方法;
};
Employee a = new Employee(){
public void work(){
}
};
a.work;
//匿名内部类的基本形式
public class Test {
public static void main(String[] args) {
//匿名内部类
Animal a = new Animal(){
@Override
public void run(){
System.out.println("老虎跑的快~~~");
}
};
a.run();
}
}
- 介绍完上面几点,我们回到封装
- 简洁的说封装是将成员变量私有
- 提供成套的getter和setter方法暴露其取值和赋值
JavaBean 也可以称为实体类,其对象可以用于在程序中封装数据。
-1. 标准JavaBean的书写要求
-2. 成员变量使用private 修饰。
-3. 提供成员变量对应的setXxx()/getXxx() 方法。
-4. 必须提供一个无参构造器(无参构造函数); 有参构造器可写可不写。
//以下是标准JavBean的书写格式
public class Car {
/**成员变量*/
private String name;
private double height;
private double salary;
/**
参数构造器(构造函数)
开始是默认有无参构造函数的
一旦定义有参数构造器,那么无参构造器就没有了
如果还想用无参构造器需要自己手写一个
*/
/**无参构造*/
public Car() {
}
/**有参构造参构造*/
public Car(String name, double height, double salary) {
this.name = name;
this.height = height;
this.salary = salary;
}
/**
提供成套的getter和setter方法暴露其取值和赋值
*/
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
以上是封装一个类的标准写法,初学者可以参考这个格式。
代码块和内部类根据实际情况写,需要的话再写