封装
一,封装的作用
封装,就是隐藏实现细节 将对象的属性和方法通常被封装在一起,共同体现事物的特性, 二者相辅相承,不能分割 将属性私有化,提供公有方法访问私有属性 通过这些公有方法访问私有属性 ,从而保证数据的安全,提高代码的可维护性
二,实现
封装的实现:
1、修改属性的可见性来限制对属性的访问
2、为每个属性创建一对赋值(setter)方法和取值(getter) 方法,用于对这些属性的访问
3、在setter和getter方法中,加入对属性的存取限制
使用封装类
package com.sk.test;
/**
* ClassName: Teacher <br/>
* Description: <br/>
* date: 2021/11/24 8:28<br/>
*
* @author 斑马<br />
*/
public class Teacher {
//1.私有化属性 private修饰符修饰的属性和方法只能在本类中访问
private String name;
private int age;
//2.给私有的属性提供 共有(public)的访问方法
//共有的设置name值的方法
public void setName(String name){
this.name=name;
}
//共有的取值方法
public String getName(){
return name;
}
public void setAge(int age){
if(age<26){//在设置值的时候限制字段
System.out.println("年龄小于26,默认为26");
this.age=26;
}else {
this.age = age;
}
}
public int getAge(){
return age;
}
}
*
* @author 斑马<br />
*/
public class TeacherTest {
public static void main(String[] args) {
Teacher teacher=new Teacher();
//直接通过属性无法访问
//teacher.name="张三";
teacher.setName("张三");
teacher.setAge(32);
String name=teacher.getName();
int age=teacher.getAge();
System.out.println("姓名:"+name+"\t年龄:"+age);
System.out.println("姓名:"+teacher.getName()+"\t年龄:"+teacher.getAge());
}
}
使用封装,增加了数据访问限制,增强了程序的可维护性
1.给属性赋值需要通过 对象名.setXxx()
2.获取属性的值需要通过 对象名.getXxx()
二,构造方法
构造方法负责对象成员的初始化工作,为实例 变量赋予合适的初始值 构造方法必须满足以下语法规则: 1、方法名与类名相同 2、没有返回类型
package com.sk.test;
/**
* ClassName: Book <br/>
* Description: <br/>
* date: 2021/11/24 9:59<br/>
*
* @author 斑马<br />
*/
public class Book {
/**无参构造*/
public Book(){//系统会为每一个类默认一个无参构造,new 对象会执行构造方法
System.out.println("无参构造执行了");
}
/**有参构造*/
public Book(String title,int pageNum){
//通过有参构造给对象赋值
this.title=title;
this.pageNum=pageNum;
}
private String title;
private int pageNum;
public void show(){
System.out.println("标题:"+title+"\t"+pageNum);
}
//Alt+Insert + getter and setter
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public int getPageNum() {
return pageNum;
}
public void setPageNum(int pageNum) {
this.pageNum = pageNum;
}
}
三,方法重载
1.在同一个类中
2.方法名相同
3.参数列表不同
4.和修饰符以及返回值类型无关
package com.sk.test;
/**
* ClassName: Driver <br/>
* Description: <br/>
* date: 2021/11/24 14:24<br/>
*
* @author 斑马<br />
*/
public class Driver {
public void a(){
System.out.println("驾驶");
}
public void a(int a){
System.out.println("驾驶一个"+a+"人的大巴");
}
public void a(int b,double money){
System.out.println("驾驶一个"+b+"人的每公里"+money+"元的出租车");
}
}
package com.sk.test;
/**
* ClassName: Master <br/>
* Description: <br/>
* date: 2021/11/24 14:28<br/>
*
* @author 斑马<br />
*/
public class Master {
public void feed(){
}
public void feed(Cat c){
System.out.println("喂养猫");
}
public void feed(Dog c){
System.out.println("喂养猫");
}
public void feed(Pig c){
System.out.println("喂养猫");
}
}
class Cat{}
class Dog{}
class Pig{}
static关键字
package com.sk.test;
/**
* ClassName: StaticTest <br/>
* Description: <br/>
* date: 2021/11/24 15:37<br/>
*
* @author 斑马<br />
*/
public class StaticTest {
StaticTest(){
}
StaticTest(int a,int b){
this.a=99;
this.b=100;
}
{//非静态的代码块
b=12;
}
static {
//静态代码块不能给非静态属性赋值
//b=22;
a=78;
}
//静态变量,属于类对象,不再属于对象的属性
static int a;
int b;
/*public static StaticTest(int b) {
this.b = b;
}*/
/**非静态方法*/
public static void a(){
//静态方法不能直接使用非静态属性
//System.out.println(b);
//静态方法不能直接调用非静态方法,只能调用静态方法和对象方法
//b();
/*StaticTest t=new StaticTest();
t.b();*/
System.out.println("静态方法");
}
public void b(){
//普通方法可以直接使用静态属性
System.out.println(a);
//普通方法可以直接使用静态方法
a();
System.out.println("非静态方法");
}
}
package com.sk.test;
/**
* ClassName: Test <br/>
* Description: <br/>
* date: 2021/11/24 15:51<br/>
*
* @author 斑马<br />
*/
public class Test {
public static void main(String[] args) {
StaticTest s=new StaticTest();
s.b=12;
//s.a=9;
StaticTest.a=12;
s.a=33;
System.out.println(s.a);
s.b();
s.a();
StaticTest.a();
StaticTest ss=new StaticTest();
System.out.println(ss.a);
System.out.println(ss.b);
}
}
类的加载顺序
1.先加载属性和方法
2.加载构造函数
3.加载代码块
代码块的作用
给属性赋值(给属性一个默认值)