成员变量与局部变量的区别:
/*
成员变量和局部变量的区别:
1:在类中的位置不同
成员变量:在类中方法外
局部变量:在方法定义中,或者方法声明上
2:在内存中的位置不同
成员变量:在堆内存
局部变量:在栈内存
3:生命周期不同
成员变量:随着对象的创建而存在,随着对象的消失而消失
局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
4:初始化值不同
成员变量:有默认的初始化值
局部变量:没有默认的初始化值,必须定义,赋值,然后才能使用
注意事项:
局部变量名称可以和成员变量名称一样,在方法中使用的时候,采用的是就近原则。
*/
class Variable{
// 成员变量
int num = 10;
public void show(){
// 局部变量
int num2 = 20;
System.out.println(num2);
}
}
class VariableDemo{
public static void main(String[] args){
// 创建对象
Variable v = new Variable();
// 访问成员变量
System.out.println(v.num);
// 调用另一个类中的方法
// 注意,一个类中的方法,是不能访问另一个类中的方法的。
v.show();
}
}
形式参数的问题:
/*
形式参数的问题:
基本类型:形式参数的改变不影响实际参数
引用类型:形式参数的改变直接影响实际参数
*/
// 形式参数是基本类型
class Demo{
public int sum(int a, int b){
return a + b;
}
}
// 形式参数是引用类型
class Student{
public void show(){
System.out.println("我爱学习");
}
}
class StudentDemo{
// 如果一个方法的形式参数是一个类类型(引用类型),这里其实需要的是该类的对象
public void method(Student s){// 调用的时候,把main方法中的s的地址传递到了这里,Student s = new Student();
s.show();
}
}
class ArgsTest{
public static void main(String[] args){
// 形式参数是基本类型的调用
// 创建对象
Demo d = new Demo();
int result = d.sum(10,20);
System.out.println("result:"+result);
// 形式参数是引用类型的调用
// 需求:调用StudentDemo类中的method方法
StudentDemo sd = new StudentDemo();
// 创建学生对象
Student s = new Student();
sd.method(s); // 把s的地址给到了这里
}
}
匿名对象的概述和应用:
/*
匿名对象:就是没有名字的对象
匿名对象的应用场景:
A:调用方法,仅仅只调用一次的时候
注意:调用多次的时候,不适合使用匿名对象
优点:匿名对象调用完毕之后就是垃圾,可以被垃圾回收器回收
B:匿名对象可以作为实际参数传递
*/
class Student{
public void show(){
System.out.println("我要坚持学习,不能放弃");
}
}
class StudentDemo{
public void method(Student s){
s.show();
}
}
class NoNameDemo{
public static void main(String[] args){
// 带名字的调用
Student s = new Student();
s.show();
// 匿名对象的调用方法
new Student().show();
new Student().show(); // 这里其实是重新创建了一个新的对象
// 匿名对象作为实际参数传递
StudentDemo sd = new StudentDemo();
sd.method(new Student());
}
}
封装概述:
- 概述:是指隐藏对象的属性和实现细节,仅对外提供公共访问方式
- 好处:
- 隐藏实现细节,提供公共访问方式
- 提高了代码的复用性
- 提高安全性
- 封装原则:
- 将不需要对外提供的内容都隐藏起来
- 把属性隐藏,提供公共方法对其访问
/*
定义一个学生类:
成员变量:name,age
成员方法;show()方法
分析:
当我们通过对象给成员变量赋值,可以赋值一些非法的数据。所以我们需要在赋值之前对数据进行判断
因此,我们决定在Student类中提供一个方法来对数据进行校验。但是仍然可以不调用方法赋值,可以
直接赋值,导致我们的方法没有作用。所以。我们应该要求必须使用方法赋值,不能直接调用成员变量赋值
解决办法:java提供了一个关键字 private
private:私有的,可以修饰成员变量和成员方法
*/
class Student{
String name;
private int age;
public void setAge(int a){
if(a < 0 || a > 120){
System.out.println("你给的年龄有问题");
}else{
age = a;
}
}
public void show(){
System.out.println("姓名:"+name);
System.out.println("年龄:"+age);
}
}
class StudentDemo1{
public static void main(String[] args){
// 创建学生对象
Student s = new Student();
s.show();
System.out.println("-----------");
// 给成员变量赋值
s.name = "乔丹";
// s.age = 45; 当age变量private后,会报错
s.setAge(27);
// 不合理数据
s.setAge(-27); // 输出,你的年龄有问题
s.show();
System.out.println("-----------");
}
}
private关键字:
- private关键字:
- 是一个权限修饰符
- 可以修饰成员(成员变量和成员方法)
- 被private修饰的成员只能在本类中使用
- 与private对应的是public关键字。
- 最常见的应用:
- 把成员变量用private修饰
- 提供对应的getXxx()h/setXxx()方法
/*
封装和private的应用:
1:把成员变量用private修饰
2:提供对应的getxxx方法和setxxx方法
*/
class Student{
// 定义私有的变量,name和age
private String name;
private int age;
// 获取值
public String getName(){
return name;
}
public int getAge(){
return age;
}
// 赋值
public void setName(String n){
name = n;
}
public void setAge(int a){
age = a;
}
}
class StudentTest{
public static void main(String[] args){
Student s = new Student();
s.setName("乔丹");
s.setAge(25);
String na = s.getName();
int ag = s.getAge();
System.out.println("姓名:"+na);
System.out.println("年龄:"+ag);
}
}
this的概述与应用:
- 作用:this代表所在类的对象引用
- 记住:方法被哪个对象调用,this就代表那个对象
- 使用this:
- 局部变量隐藏成员变量
- 其他方法后面和super一起说
/*
this的使用:
*/
class Student{
// 定义私有的变量,name和age
private String name;
private int age;
// 获取值
public String getName(){
return name; // 这里其实隐含了this
}
public int getAge(){
return age;
}
// 赋值
public void setName(String name){
// this.name 代表当前类的对象调用name
this.name = name;
}
public void setAge(int age){
// this.age 代表当前类的对象调用age
this.age = a;
}
}
this的内存图:
构造方法:
/*
构造方法:
给对象的数据进行初始化
构造方法格式:
1.方法名与类名相同
2.没有返回值类型,连void都没有
3.没有具体的返回值
构造方法的注意事项:
1.如果我们没有给出构造方法,系统将自动提供一个无参构造方法。
2.如果我们给出了构造方法,系统将不再提供默认的无参构造方法。
如果想要使用无参构造方法,就必须自己给出,建议永远自己给出无参构造方法
*/
class Student{
private String name;
private int age;
// 我们自定义的构造方法。
public Student(){
System.out.println("这是构造方法");
}
// 构造方法的重载
public Student(String name){
this.name = name;
}
public void show(){
System.out.println(name+"---"+age);
}
}
class ConstructDemo{
public static void main(String[] args){
// 创建对象
Student s = new Student(); // 此处使用的就是构造方法
s.show();
// 创建对象2
Student s2 = new Student("小明");
s2.show();
}
}
一个类的完整版
/*
类的组成:
成员变量
成员方法
根据返回值:
void类型
非void类型
形式参数:
空参方法
非空参方法
构造方法
需求:写一个标准代码的版本
学生类:
成员变量:name,age
构造方法:无参,带两个参
成员方法:getxxx()/setxxx(),show()
给成员变量赋值:
A:setxxx()
B:构造方法
输出成员变量的方法:
A:通过setxxx()分别获取然后拼接
B:通过调用show()方法
*/
class Student{
// 姓名
private String name;
// 年龄
private int age;
// 构造方法
public Student(){
}
public Student(String name, int age){
this.name = name;
this.age = age;
}
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
// 输出所有的成员变量值
public void show(){
System.out.println(name+"----"+age);
}
}
// 测试类
class StudentTest1{
public static void main(String[] args){
// 方式1:给成员变量赋值
// 无参构造+setxxx()
Student s1 = new Student();
s1.setName("小明");
s1.setAge(27);
// 输出值
System.out.println(s1.getName()+"----"+s1.getAge());
s1.show();
// 方式2:给成员变量赋值
// 构造方法
Student s2 = new Student("小李",30);
// 输出值
System.out.println(s2.getName()+"----"+s2.getAge());
s2.show();
}
}
static关键字:
针对多个对象有共同的成员变量的时候,Java提供了一个关键字static来修饰
/*
static关键字:
可以修饰成员变量和成员方法
特点:
1.随着类的加载而加载
main方法
2.优先于对象存在
3.被类的所有对象共享
4.可以通过类名调用
注意事项
1.在静态方法中,没有this关键字。
2.静态方法只能访问静态的成员变量和成员方法。
静态方法:
成员变量:只能访问静态变量
成员方法:只能访问静态成员方法
非静态方法:
成员变量:可以是静态的,也可以是非静态的。
成员方法:可以是静态的成员方法,也可以是非静态的成员方法。
*/
class Student{
// 非静态变量
int num = 10;
// 静态变量
static int num2 = 20;
}
class StudentDmeo1{
public static void main(String[] args){
Student s = new Student();
System.out.println(s.num);
// 用类名调用,也可以用对象名调用,推荐使用类名调用。
System.out.println(Student.num2);
}
}
静态变量和成员变量的区别:
- 所属不同
- 静态变量属于类,所以也称为类变量
- 成员变量属于对象,所以也称为实例变量(对象变量)
- 内存中位置不同
- 静态变量存储于方法区的静态区
- 成员变量存储于堆内存
- 内存出现时间不同
- 静态变量随着类的加载而加载,随着类的消失而消失
- 成员变量随着对象的创建而存在,随着对象的消失而消失
- 调用不同
- 静态变量可以通过类名调用,也可以通过对象调用
- 成员变量只能通过对象名调用