成员变量和局部变量的区别
在类中的位置不同
成员变量 类中方法外
局部变量 方法内或者方法声明上
在内存中的位置不同
成员变量 堆内存
局部变量 栈内存
生命周期不同
成员变量 随着对象的存在而存在，随着对象的消失而消失
局部变量 随着方法的调用而存在，随着方法的调用完毕而消失
初始化值不同
成员变量 有默认的初始化值 局部变量
没有默认的初始化值，必须先定义，赋值，才能使用。
面向对象类的定义以及测试
手机事物-----使用面向对象的方式: 定义手机类
品牌,价格,颜色,内存的属性
打电话,发短信,玩游戏,学习的行为
//先定义一个手机类
class Phone{
//成员变量
String brand ; //品牌
int price ; //价格
String color ;//颜色
int memory ; //内存
//成员方法
public void callPhone(String toName){ //参数toName:给谁打电话
System.out.println("给"+toName+"打电话") ;
}
public void sendMsg(){
System.out.println("可以使用手机发短信...") ;
}
public String playGame(String gameName){
return "可以玩"+gameName+"游戏" ;
}
public void study(String className){
System.out.println("学习"+className) ;
}
}
//手机类的测试类
class PhoneTest{
public static void main(String[] args){
//测试手机类
//类名 对象名 = new 类名() ;
Phone phone = new Phone() ;
System.out.println(phone) ;
System.out.println("当前手机的品牌是:"+phone.brand+",价格是:"+phone.price+",手机颜色:"+phone.color+",手机内存是:"+phone.memory+"G");
System.out.println("---------------------") ;
//访问成员变量
phone.brand = "华为mate30pro" ;
phone.price = 6999 ;
phone.color = "粉翠绿" ;
phone.memory = 64;
System.out.println("当前手机的品牌是:"+phone.brand+",价格是:"+phone.price+",手机颜色:"+phone.color+",手机内存是:"+phone.memory+"G");
System.out.println("-----------------------------") ;
//访问成员方法
phone.callPhone("高圆圆") ;
phone.sendMsg() ;
String result = phone.playGame("csgo") ;
System.out.println(result) ;
phone.study("JavaEE") ;
}
}匿名对象
匿名对象：就是没有名字的对象。 是对象的一种简化表示形式
在android应用中匿名对象使用很多 节省内存空间
匿名对象的两种使用情况
对象调用方法仅仅一次的时候
作为实际参数传递
格式
//定义学生类
class Student{
public void study(){
System.out.println("爱生活,爱Java,爱敲代码...") ;
}
}
//定义StudentDemo类
class StudentDemo{
public void method(Student student){
student.study() ;
}
}
//测试类
class NoNameObjectDemo{
public static void main(String[] args){
//之前的写法
//访问StudentDemo类中的method 方法
//创建StudentDemo类对象
StudentDemo sd = new StudentDemo() ;
//创建一个具体的学生对象
Student s = new Student() ;
sd.method(s) ;
System.out.println("------------------------------") ;
//方式2
StudentDemo sd2 = new StudentDemo() ;
sd2.method(new Student()) ;
System.out.println("------------------------------") ;
//链式编程
//一步走
new StudentDemo().method(new Student()) ;
}
}1:new Student().show();
2:new StudentTest().method(new StudentDemo())
封装概述
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
封装原则： 将不需要对外提供的内容都隐藏起来。 把属性隐藏，提供公共方法对其访问。
优点
隐藏实现细节，提供公共的访问方式
提高了代码的复用性
提高安全性。
引入一个关键字！！！！
private关键字
是一个权限修饰符。
可以修饰成员(成员变量和成员方法)
被private修饰的成员只在本类中才能访问。
private最常见的应用：
把成员变量用private修饰
提供对应的getXxx()/setXxx()方法
一个标准的案例的使用
Demo
//手机类 加入封装
/*
手机事物:
属性:品牌:brand 价格:price 颜色:color 内存:memory
行为:打电话,学习
加入封装:定义一个手机类描述手机事物,并且属性私有化
*/
//定义一个手机类
class Phone{
//成员变量:私有化
private String brand ; //品牌
private int price ; //价格
private String color ; //颜色
private String memory ;//内存 "G"
//公共访问方法:setXXX()/getXXX()方法为私有的成员进行赋值和获取值
//给品牌属性赋值
public void setBrand(String b){
brand = b ;
}
//获取品牌的值
public String getBrand(){
return brand ;
}
//给价格赋值
public void setPrice(int p){
price = p ;
}
//获取价格
public int getPrice(){
return price ;
}
//给手机颜色赋值
public void setColor(String c){
color = c ;
}
//获取颜色
public String getColor(){
return color ;
}
//给手机内存赋值
public void setMemory(String m){
memory = m ;
}
//获取内存
public String getMemory(){
return memory ;
}
//其他成员方法
//打电话
public void call(String toName){
System.out.println("可以给"+toName+"打电话了...") ;
}
//学习
public void study(){
System.out.println("使用手机可以学习任何技术...") ;
}
}
//测试类
class PhoneTest{
public static void main(String[] args){
//创建手机类对象
Phone p = new Phone() ;
//通过setXXX()属性赋值
p.setBrand("华为mate30") ;
p.setPrice(5999) ;
p.setColor("天空灰") ;
p.setMemory("128G") ;
//输出
System.out.println("手机品牌是:"+p.getBrand()+",价格为:"+p.getPrice()+","
+"颜色是:"+p.getColor()+",内存大小为:"+p.getMemory()) ;
p.call("彭于晏") ;
p.study() ;
}
}
/*
给学生类中的成员加入私有修饰,对外提供公共的方法(setXXX()/getXXX())
学生事物:
姓名,年龄,性别,爱好的属性
学习,玩游戏,运动的行为
定义一个学生描述学生事物并在StudentTest2中测试
*/
class Student2{
//成员变量私有化
private String name ;//姓名
private int age ; //年龄
private String gender ;//性别
private String hobit ; //爱好
//成员方法
public void study(){
System.out.println("学习JavaEE...") ;
}
//玩游戏
public String playGame(String gameName){
return "会玩"+gameName ;
}
//运行
public void sport(){
System.out.println("喜欢踢足球...") ;
}
//一些公共访问方法:给姓名,年龄,性别,爱好赋值 /还需要获取这些内容
//给学生的姓名赋值
public void setName(String n){ //"高圆圆"
name = n ;//name = n = "高圆圆"
}
//获取学生的姓名--->返回值:String
public String getName(){
return name ;
}
//给学生的年龄赋值
public void setAge(int a){ //41
age = a ; //age = a = 41
}
//获取学生的年龄:int类型
public int getAge(){
return age ;
}
//给学生的性别赋值
public void setGender(String g){ //"女"
gender = g ; //gender = g ="女"
}
//获取学生的性别:String
public String getGender(){
return gender ;
}
//给学生的爱好赋值
public void setHobit(String h){ //"跑步"
hobit = h ; //hobit = h = "跑步"
}
//获取学生的爱好:String
public String getHobit(){
return hobit ;
}
}
//测试类
class StudentTest2{
public static void main(String[] args){
//创建学生类测试
Student2 s = new Student2() ;
/*
s.name = "高圆圆" ;
s.age= 41 ;
s.gender = "女" ;
s.hobit = "跑步" ;
*/
//对象名.公共的成员方法名() 赋值
s.setName("高圆圆") ;
s.setAge(41) ;
s.setGender("女") ;
s.setHobit("跑步") ;
System.out.println("当前学生的姓名是:"+
s.getName()+",年龄是:"+s.getAge()+",性别是:"+s.getGender()+",爱好是:"+s.getHobit()) ;
//其他成员方法
s.study() ;//学习
String str = s.playGame("lol") ;
System.out.println(str) ;
s.sport() ;
}
}this关键字
给属性赋值的时候:局部变量隐藏了成员变量:名称相同，不好区分
Java此时提供关键字this:解决局部变量隐藏了成员变量
this.成员变量名 = 局部变量;
this:就是代表当前类的对象的地址值引用!
注意setXXX；getXXX
//定义一个手机类
class Phone{
//成员变量:私有化
private String brand ; //品牌
private int price ; //价格
private String color ; //颜色
private String memory ;//内存 "G"
//公共访问方法:setXXX()/getXXX()方法为私有的成员进行赋值和获取值
//给品牌属性赋值
//public void setBrand(String b){
public void setBrand(String brand){//品牌 "华为mate30"
//brand = b ;
this.brand = brand ;//"华为mate30"
}
//获取品牌的值
public String getBrand(){
return brand ; //getXXX()---隐藏this
//return this.brand ;
}
//给价格赋值
//public void setPrice(int p){
public void setPrice(int price){
//price = p;
this.price = price ;
}
//获取价格
public int getPrice(){
return price ;
}
//给手机颜色赋值
//public void setColor(String c){
public void setColor(String color){
//color = c ;
this.color = color;
}
//获取颜色
public String getColor(){
return color ;
}
//给手机内存赋值
//public void setMemory(String m){
public void setMemory(String memory){
//memory = m ;
this.memory = memory ;
}
//获取内存
public String getMemory(){
return memory ;
}
//其他成员方法
//打电话
public void call(String toName){
System.out.println("可以给"+toName+"打电话了...") ;
}
//学习
public void study(){
System.out.println("使用手机可以学习任何技术...") ;
}
}
//测试类
class PhoneTest{
public static void main(String[] args){
//创建手机类对象
Phone p = new Phone() ;
//通过setXXX()属性赋值
p.setBrand("华为mate30") ;
p.setPrice(5999) ;
p.setColor("天空灰") ;
p.setMemory("128G") ;
//输出
System.out.println("手机品牌是:"+p.getBrand()+",价格为:"+p.getPrice()+","
+"颜色是:"+p.getColor()+",内存大小为:"+p.getMemory()) ;
p.call("吴亦凡") ;
p.study() ;
}
}构造方法
构造方法格式
1)构造方法名和类名一致
2)没有具体的返回值类型
3)连void都没有构造方法的目的:为了给类的成员的一些数据进行初始化
构造方法注意事项
如果你不提供构造方法，系统会给出默认构造方法
如果你提供了构造方法，系统将不再提供
构造方法也是可以重载的
给成员变量赋值有几种?
提供的公共的访问方法:setXXX()
构造方法
有参与无参构造
//定义一个学生类
class Student{
private String name ;//姓名
private int age ; //年龄
//无参构造方法
public Student(){
System.out.println("这是Student类的无参构造方法...") ;
}
//定义有参构造方法(带一个String类型的参数)
public Student(String name){ //局部变量 "高圆圆"
//this.name = name ;
System.out.println("这是Student类带String类型的有参构造方法...") ;
}
//带一个int类型的有参构造方法
public Student(int age){
System.out.println("这是Student类带int类型的有参构造方法...") ;
}
//测试类
class ConstructorDemo{
public static void main(String[] args){
//创建学生类对象
Student s = new Student() ; //无参
Student s2 = new Student("高圆圆") ; //有参
Student s3 = new Student("41") ;手机：牌子，价格，颜色
//手机类
class Phone{
private String brand ;
private int price ;//价格
private String color ;
public Phone(){
}
//提供了带参数构造方法
//("锤子手机",1299,"黑色"
public Phone(String brand,int price ,String color){//局部变量
this.brand = brand ;
this.price = price ;
this.color = color ;
}
//提供setXXX()/getXXX()方法
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 ;
}
//其他成员方法(手机事物的行为)
}
//测试类
class ConstructorDemo2{
public static void main(String[] args){
//通过无参构造方法创建对象
//方式1:无参构造方法+setXXX()/getXXX()
Phone p = new Phone();//
//setXXX()赋值
p.setBrand("锤子手机") ;
p.setPrice(1299) ;
p.setColor("黑色") ;
System.out.println("品牌:"+p.getBrand()+",价格:"+p.getPrice()+",颜色:"+p.getColor()) ;
System.out.println(p) ;
System.out.println("---------------------") ;
//方式2:通过有参构造方法赋值 + 结合getXXX()获取内容
Phone p2 = new Phone("锤子手机",1299,"黑色") ;
System.out.println("品牌:"+p2.getBrand()+",价格:"+p2.getPrice()+",颜色:"+p2.getColor()) ;
}
}一个基本类的标准写法
类
成员变量
构造方法
无参构造方法
带参构造方法
成员方法
getXxx()
setXxx()
给成员变量赋值的方式
无参构造方法+setXxx()
带参构造方法
基本类的标准写法
一个标准类的写法
class 类名{
//成员变量私有化
//提供无参构造方法
//提供有参构造方法
//提供setXXX()/getXXX()方法
//给成员变量赋值:
//1)通过无参构造方法创建对象,在通过setXXX()进行赋值,getXXX()方法获取成员变量的值;
//2)直接有参构造方法创建对象,并且直接赋值,再通过getXXX()方法获取成员变量的值;}
学生类
属性:私有化 姓名,年龄,性别,学号
行为:吃,睡,学习
公共访问方法setXXX()/getXXX()
构造方法:
无参构造方法/有参构造方法
class Student{
//属性私有化
private String name ;//姓名
private int age ; //年龄
private String gender ;//性别
private String sid ; //学生学号
//无参构造方法
public Student(){
}
//有参构造方法
public Student(String name,int age,String gender,String sid) {
//赋值
this.name = name ;
this.age = age ;
this.gender = gender ;
this.sid = sid ;
}
//提供setXXX()/getXXX()方法
//给姓名赋值
public void setName(String name){
this.name = name ;
}
//获取姓名
public String getName(){
return name ;
}
//给年龄赋值
public void setAge(int age){
this.age = age ;
}
//获取年龄
public int getAge(){
return age ;
}
//给性别赋值
public void setGender(String gender){
this.gender = gender ;
}
//获取性别
public String getGender(){
return gender ;
}
//给学号赋值
public void setSid(String sid){
this.sid = sid ;
}
//获取学号
public String getSid(){
return sid ;
}
//吃
public void eat(){
System.out.println("学生吃营养餐...") ;
}
//睡
public void sleep(){
System.out.println("学习累了就需要休息") ;
}
//学习
public void study(){
System.out.println("学习JavaSE...") ;
}
}
//测试类
class StudentTest{
public static void main(String[] args){
//测试学生类
//方式1:通过无参构造方法 + setXXX()/getXXX()
Student s = new Student() ;
s.setName("亚索") ;
s.setAge(23) ;
s.setGender("男") ;
s.setSid("s007") ;
//获取内容
System.out.println("姓名为:"+s.getName()+",年龄是:"+s.getAge()+",性别是:"+s.getGender()+",学号是:"+s.getSid()) ;
s.eat() ;
s.sleep() ;
s.study() ;
System.out.println("----------------------------------------") ;
//方式2:通过有参构造方法赋值+getXXX()获取内容
Student s2 = new Student("李青",45,"男","s008") ;
System.out.println("姓名为:"+s2.getName()+",年龄是:"+s2.getAge()+",性别是:"+s2.getGender()+",学号是:"+s2.getSid()) ;
s2.eat() ;
s2.sleep() ;
s2.study() ;
}
}static关键字
什么是静态(static),
特点:
1)随着类的加载而加载
2)优先于对象存在: 它不能this共存 (this:代表当期类对象的地址值引用)
对象还没有new的时候,当前被static修饰的成员就已经内存了
3)被静态修饰的 可以被多个对象共享:有共享共用的意思
举例:
饮水机中的水(适合)
水杯共享(不适合!)
4)被静态修饰的变量,方法----->静态变量或者静态方法
我们所说的成员变量和成员方法:都指的是非静态
静态的成员的访问方式:类名.变量
类名.方法名()
使用注意事项
关于static关键字的使用注意事项
1)非静态的方法：既可以访问静态变量,也可以访问非静态的变量
既可以调用静态方法,也可以调用非静态方法
2)静态的方法：只能访问静态变量,
只能调用静态方法
简单记:静态只能访问静态！！！
class Demo2{
//非静态成员变量
public int num = 10 ;
//静态变量
public static int num2 = 20 ;
//定义一个非静态方法
public void show(){
System.out.println(num);
System.out.println(num2);
}
//非静态方法
public void function(){
//调用非静态方法
show() ;
method();
}
//静态方法
public static void method(){
//System.out.println(num); //非静态变量
System.out.println(num2);
//show(); 非静态的方法
function2();
System.out.println("method demo2...");
}
//静态方法
public static void function2(){
System.out.println("function2 demo2...");
}
}
//测试类
public class StaticDemo2 {
public static void main(String[] args) {
//访问Demo2类中的show方法
Demo2 d = new Demo2() ;
d.show() ;
System.out.println("------------------------");
d.function();
System.out.println("-------------------------");
Demo2.method();
int result = add(10,20) ;
System.out.println(result);
}
//求两个数据之和
public static int add(int a,int b){
return a+ b ;
}
}版权声明：本文为weixin_47082759原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。