一、封装：
- private关键字的特点:
被private修饰的成员变量/成员方法,都只能在本类中访问;
外界类不能直接访问,但是可以通过公共方法间接访问
举例1：
class Code{
//成员变量
int num = 20 ;
//私有成员变量
private int num2 = 30 ;
//定义一个method方法:公共的
public void method(){
System.out.println(num) ;
System.out.println(num2) ;
}
//私有的成员方法
private void function(){
System.out.println("function code...") ;
}
public void show(){
System.out.println("show code...");
function() ;
}
}
//测试类
class privateDemo{
public static void main(String[] args){
//要访问Code类中num和num2
Code code = new Code() ;
System.out.println(code.num) ;
//System.out.println(code.num2) ;//num2 在 Code 中是 private 访问控制
code.method() ;
System.out.println("--------------") ;
//code.function() ;// function() 在 Code 中是 private 访问控制
code.show() ;
}
}
举例2：
/*
需求:
将昨天手机类:品牌(brand),价格(price),颜色(color),手机内存(memory)
行为:打电话,发短信
将属性全部私有化,提供对外的公共访问方法,测试!
*/
//定义一个手机类
class Phone{
//属性私有化
private String brand ;//品牌
private int price ; //价格
private String color ;//颜色
private int memory ; //手机内存
//成员方法
//setXXX(xxx xx)
//给品牌赋值
public void setBrand(String b){
brand = b ;
}
//给价格赋值
public void setPrice(int p){
price = p ;
}
//给颜色赋值
public void setColor(String c){
color = c ;
}
//给手机内存赋值
public void setMemory(int m){
memory = m ;
}
//获取品牌
public String getBrand(){
return brand ;
}
//获取价格
public int getPrice(){
return price ;
}
//获取颜色
public String getColor(){
return color ;
}
//获取手机内存
public int getMemory(){
return memory ;
}
//打电话,发短信
public void callPhone(){
System.out.println("手机可以打电话") ;
}
public void sendMessage(){
System.out.println("手机可以发短信...") ;
}
}
//手机类的测试类
class PhoneTest{
public static void main(String[] args){
//测试
//创建一个手机类对象
Phone p = new Phone() ;
p.setBrand("华为 mate30") ;
p.setPrice(4999) ;
p.setColor("天空灰") ;
p.setMemory(32) ;
//获取内容
System.out.println("手机的品牌是"+p.getBrand()+
",价格式:"+p.getPrice()+",机身颜色是:"+p.getColor()+",它的内存大小为:"+p.getMemory()) ;
p.callPhone();
p.sendMessage() ;
}
}
举例3：
/*
需求:
学生事物,有姓名和年龄两个属性
行为:学习
定义一个学生类,描述学生的基本想信息
按照上面的需求:给学生的年龄赋值一个负数,依然可以输出 ,属于非法数据!
如何改进这个程序?
提供一个功能setAge(int num):判断学生的年龄
如果年龄<0或者年龄>150,都是属于非法数据,提示一下!
如果年龄在正常范围内:将值赋值给age
setAge(int num):是定义在Student类中还是定义在测试类中?
测试类目的:主要测试学生类的功能,不应该出现其他功能
将setAge(int num)定义在学生类中
定义这个功能,可以使用,也可以不使用!
当前的这个学生类的属性任何情况都是可以访问,给年龄一个负数,这个写法不安全
Java提供了一个关键字:private
封装:
将一个事物的属性,私有化(对外进行隐藏),外界不能直接访问(保证了数据安全性),需要提供对外的
公共访问来访问成员变量!
private:
私有的,外界无法访问的,只能在本类中访问
*/
class Student{
String name ; //姓名
private int age ; // 年龄
//学习
public void study(){
System.out.println("学习JavaSE...") ;
}
//判断学生的年龄
public void setAge(int num){
if(num < 0 || num > 150){
System.out.println("学生的年龄非法!") ;
}else{
age = num ;
}
}
//公共方法
public void show(){
System.out.println(name+"---"+age) ;
}
}
//学生类的测试类
class StudentDemo{
public static void main(String[] args){
//创建一个具体事物
//类名 对象名 = new 类名() ;
Student s = new Student() ;
//给成员变量赋值
//s.name = "高圆圆" ;
//s.age = 30 ;
//System.out.println(s.name+"---"+s.age) ;
//System.out.println("-------------------------") ;
//继续赋值
//s.name = "赵又廷" ;
//s.age = -32 ;
//System.out.println(s.name+"--- "+s.age) ;
//s.name = "赵又廷" ;
//s.setAge(-32) ;
//s.age = -32 ;
//
s.name = "高圆圆" ;
//s.age = 41 ;
s.show() ;
}
}
举例4：
/*
将学生类进行改造
将name,age属性私有化
只能在本类访问,外界要访问,需要通过公共方法访问
赋值/获取值 setxxx()getxxx() (成员方法)
*/
//定义一个学生类
class Student{
//成员变量:name,age 私有化
private String name ;
private int age ;
//提供对外的公共访问方法: 去掉static
//给学生姓名赋值
public void setName(String n){ //"高圆圆"
name = n ;
}
//给学生年龄赋值
public void setAge(int a){ // 30
age = a ;
}
//获取学生的姓名
public String getName(){
return name ;
}
//获取学生的年龄
public int getAge(){
return age ;
}
//成员方法:学习
public void study(){
System.out.println("学习JavaSE_面向对象部分") ;
}
}
//测试类
class StudentTest{
public static void main(String[] args){
//创建一个学生类对象
Student s = new Student() ;
System.out.println(s.getName()+"---"+s.getAge()) ;
//s.name = "高圆圆" ;
//s.age = 30 ;
//公共访问:setXXX()赋值
s.setName("高圆圆") ;
s.setAge(30) ;
//公共访问方法:setXXX()获取值
System.out.println(s.getName()+"---"+s.getAge()) ;
}
}
二、this关键字：代表了当前类的对象的地址值的引用!
举例：
/*
需求:定义学生类
姓名,和年龄两个属性,属性私有化,提供公共访问方法赋值/获取值
吃,睡,学习,玩游戏
按照上面写完之后,
set方法赋值的时候,局部变量n,a:不能满足 ("标识符的规则":见名知意)
将n,a---->name,age
给学生姓名赋值:
public void setName(String name) ;
name = name ;
}
局部变量和成员变量都叫name,如何区分呢? 这个时候Java提供了一个关键字:this
局部变量隐藏了成员变量,使用this关键字来区分
this:代表了当前类的对象的地址值的引用!
*/
class Student{
private String name ;
private int age ;
//setXXX(xxx)方法
//public void setName(String n){
public void setName(String name){
//name = n ;
//name = name ;
this.name = name ; //区分了成员变量和局部变量
}
/*
public void setAge(int a){
age = a ;
}
*/
public void setAge(int age){
//age = age ;
this.age = age ;
}
//getXXX()
public String getName(){
return name ;
}
public int getAge(){
return age ;
}
//eat
public void eat(){
System.out.println("学习饿了,就需要吃饭...") ;
}
public void sleep(){
System.out.println("学习困了,就需要休息") ;
}
public void study(){
System.out.println("学习JavaEE...") ;
}
}
//测试类
class StudentTest{
public static void main(String[] args){
//创建学生类对象
Student s = new Student() ;
s.setName("高圆圆") ;
s.setAge(30) ;
System.out.println(s.getName()+"---"+s.getAge()) ;
s.eat() ;
s.sleep() ;
s.study() ;
}
}
三、构造方法：
- 构造方法是一个方法,特殊的方法
1)方法名和类名一致!
2)没有具体返回值类型
3)连void都没有 - 格式:
权限修饰符(public:目前使用居多) + 类名(xx){}
//老师类
class Teacher{
//定义构造方法:无参的构造方法
public Teacher(){
System.out.println("这是Teacher类的无参构造方法...");
}
//teach
public void teach(){
System.out.println("老师讲解JavaEE...") ;
}
}
//测试类
class ConstructorDemo{
public static void main(String[] args){
//创建Teacher类对象
Teacher t = new Teacher() ;
t.teach() ;
}
}
-
构造方法的分类:
无参构造方法
有参构造方法
构造方法作用:
就是为了 给类中的成员变量进行数据的初始化!(构造方法初始化!)构造方法是可以重载的;
-
注意事项:
当前我们定义一个类的时候,没有提供任何构造方法,那么系统会默认无参构造方法;
但是,如果我们提供一个有参构造方法,系统不会在提供无参构造方法!(建议永远给出无参构造方法)
一个类的组成:
1). 成员变量
2).加入构造方法
无参
有参构造方法
3).成员方法
//学生类
class Student{
//属性私有化
private String name ;//姓名
private int age ;//年龄
//无参构造方法
public Student(){
System.out.println("这是Student类的无参构造方法") ;
}
//带一个参数的构造方法:String类型的参数
public Student(String name){
System.out.println("这是Student类带一个String类型的构有参构造方法...") ;
}
//带一个int类型构造方法
public Student(int age){
System.out.println("这是Student类带一个int类型的构有参构造方法...") ;
}
//带两个参数的有参构造
public Student(String name,int age){
System.out.println("这是Student类的带两个参数的有参构造方法...") ;
}
}
//测试类
class ConstructorDemo2{
public static void main(String[] args){
//创建第一个学生类对象
Student s = new Student() ;
System.out.println("---------------------") ;
//s2
Student s2 = new Student("高圆圆") ;
System.out.println("---------------------") ;
//s3
Student s3 = new Student(41) ;
System.out.println("---------------------") ;
Student s4 = new Student("赵又廷",38) ;
//Student s5 = new Student(38,"赵又廷") ;
}
}
-
一个标准类的写法(正式写法)
需求:定义学生类
姓名,和年龄两个属性,属性私有化,提供公共访问方法赋值/获取值
吃,睡,学习,玩游戏定义学生类,加入新的成员:构造方法
成员变量:属性私有化:name,age
构造方法:
无参构造/有参构造方法
成员方法:setXXX()/getXXX(),吃,睡,学习,玩游戏给类的成员变量赋值有几种方式:
1)setXXX(xxx) :公共方法赋值
2)类的有参构造方法直接赋值;改造手机类:加入新的成员:构造方法(Constructor)
举例1：
class Student{
//属性私有化
private String name ; //姓名
private int age ; //年龄
//无参构造方法(永远给出)
public Student(){
}
//有参构造方法
public Student(String name,int age){//"张佳宁",30
this.name = name ;
this.age = age ;
}
//提供成员方法
//setXXX()getXXX()
public void setName(String name){
this.name = name ;
}
public String getName(){
return name ; //隐藏 : return this.name ; 将this省略了
}
public void setAge(int age){
this.age = age ;
}
public int getAge(){
return age ;
}
//提供其他成员方法
public String study(String className){
return "正在学习"+className;
}
public void playGame(){
System.out.println("学生可以玩游戏...") ;
}
}
//测试类
class Test{
public static void main(String[] args){
//方式1:无参构造方法+setXXX() +getXXX()
Student s = new Student() ;
s.setName("高圆圆") ;
s.setAge(41) ;
System.out.println("学生的姓名是"+s.getName()+",年龄是:"+s.getAge()) ;
String result = s.study("JavaEE") ;
System.out.println(result) ;
s.playGame() ;
System.out.println("----------------------------------") ;
//方式2:有参构造方法+getXXX()
Student s2 = new Student("张佳宁",30) ;
System.out.println("学生的姓名是"+s2.getName()+",年龄是:"+s2.getAge()) ;
String result2 = s2.study("Python") ;
System.out.println(result2) ;
s2.playGame() ;
}
}
举例2：
//定义一个手机类
class Phone{
//属性私有化
private String brand ;
private int price ;
private String color ;
private int memory ;
//无参构造方法
public Phone(){}
//有参构造方法
public Phone(String brand,int price,String color,int memory){
this.brand = brand ;
this.price = price ;
this.color = color ;
this.memory = memory ;
}
//set方法
public void setBrand(String brand){
this.brand = brand ;
}
public String getBrand(){
return brand ;
}
public void setPrice(int price){
this.price = price ;
}
public int getPrice(){
return price ;
}
public void setColor(String color){
this.color = color ;
}
public String getColor(){
return color ;
}
public void setMemory(int memory){
this.memory = memory ;
}
public int getMemory(){
return memory ;
}
public void callPhone(String callTo){
System.out.println("可以给"+callTo+"打电话") ;
}
public void playGame(String gameName){
System.out.println("可以玩"+gameName) ;
}
}
//测试
class Test2{
public static void main(String[] args){
//方式1:无参+setxxx()/getxxx()
Phone p = new Phone() ;
p.setBrand("apple") ;
p.setPrice(4599) ;
p.setColor("土豪金") ;
p.setMemory(16) ;
System.out.println(p.getBrand()+"---"+p.getPrice()+"---"+p.getColor()+"---"+p.getMemory()) ;
p.callPhone("高圆圆") ;
p.playGame("王者农药") ;
System.out.println("-------------") ;
//方式2:有参构造+getxxx()
Phone p2 = new Phone("华为",6799,"翡翠绿",32) ;
System.out.println(p2.getBrand()+"---"+p2.getPrice()+"---"+p2.getColor()+"---"+p2.getMemory()) ;
p2.callPhone("高圆圆") ;
p2.playGame("王者农药") ;
}
}
987
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
