Java从入门到放弃06—面向对象/成员变量和局部变量的区别/this关键字/匿名对象/封装（private关键字）

01 面向对象的思想

• 创建一个类，将实现某种功能的具体步骤封装在该类下。使用的时候，根据需求找到对应的类。

• 特征:封装/继承/多态

02 类和对象的概念

• 类：一组相关的属性和行为的集合 对象：该类事物的具体体现 eg.学生类里的某一对象为班长

• 类的组成：成员变量和成员方法

• 类的使用：

  文件名问题：java文件名建议与测试类名称一致
  使用：通过创建对象使用类
  对象的创建格式：类名 对象名=new 类名（）;
  成员变量的使用：对象名.变量名
  成员方法的使用：对象名.方法名（实参);

• 注意事项：一个Java文件中，可以定义多个类，有什么注意的，注意 public 只能在一个有main方法的类可以加上，其他类不能加public

• 以一个手机类为例

class PhoneTest{
public static void main(String[] args){
Phone phone=new Phone();//创建对象
String brand=phone.brand;//获取成员变量
String color=phone.color;
String storage=phone.storage;
phone.call(brand);//使用成员方法
phone.sendMsg(brand);
}
}
class Phone{//创建一个手机类
String brand="Samsung";//成员变量（成员变量不赋值时有默认值）
String color="blue";
String storage="64g";
public void call(String brand){//成员方法
System.out.println("用"+brand+"打电话");
}
public void sendMsg(String brand){
System.out.println("用"+brand+"发短信");
}
}
运行结果：用Samsung打电话
用Samsung发短信

• 以一个学生类为例

public class StudentTest {
public static void main(String[] args) {
Student s1 = new Student();
s1.name="Jay";
s1.age=23;
s1.homeWork();
s1.sleep();
Student s2 = new Student();
s2.name="JJ";
s2.age=21;
Student s3=s1;//s3与s1引用同一空间，因此无论是s1还是s3对成员变量进行重新赋值，都会改变该空间下的成员变量。
s3.name="leehom";
s3.age=28;
s1.age=30;
System.out.println(s1.name);//输出最后一次该引用空间下成员变量name，应为leehom
System.out.println(s1.age);//输出最后一次该引用空间下成员变量age的值，应为30
System.out.println(s2.name);
System.out.println(s2.age);
System.out.println(s3.name);//输出最后一次该引用空间下成员变量name，应为leehom
System.out.println(s3.age);//输出最后一次该引用空间下成员变量age的值，应为30
}
}
class Student {
String name;
int age;
public void homeWork(){
System.out.println("Do homework");
}
public void sleep(){
System.out.println("Go sleep");
}
}
运行结果：Do homework
Go sleep
leehom
30
JJ
21
leehom
30

03 成员变量和局部变量的区别

• 在类中的位置不同
  成员变量：在类中方法外
  局部变量：在方法定义中或者方法声明上（形参）
• 在内存中的位置不同
  成员变量：在堆内存
  局部变量：在栈内存
• 生命周期不同
  成员变量：随着对象的创建而存在，随着对象的消失而消失
  局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
• 初始化值不同
  成员变量：有默认初始化值
  局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。

04 参数传递问题/this关键字

• 总结1：基本数据类型：形式参数的改变不影响实际参数
  引用数据类型：形式参数的改变直接影响实际参数

public class MyTest {
public static void main(String[] args) {
Dog dog = new Dog();//该对象在堆内存中引用某一空间
String name = "小花";//局部变量，存储在栈内存中
int num = 100;//局部变量，存储在栈内存中
dog.show(dog, name, num);//调用dog类中的show方法，形参中的dog是该类的对象名，该方法执行完毕后，弹栈。引用空间会继续保留一段时间，直到main{}中不再引用该空间下的任何变量，JAVA会对该空间进行回收。
System.out.println(dog.name);//3.dog.name指向引用空间中的name变量kitty
System.out.println(dog.age);// 4.dog.age指向引用空间中的age变量101
System.out.println(name);// 5.输出栈内存中name变量小花
System.out.println(num);// 6.输出栈内存中的num变量100
}
}
class Dog {
String name;
int age;
public void show(Dog dog1, String name, int num) {
System.out.println("这个方法调用了");
name = "kitty";
num = 100 + 1;
dog1.name = name;
dog1.age = num;
System.out.println(name);//1.该方法对引用空间的name变量重新赋值kitty
System.out.println(num);//2.该方法对引用空间中的num变量重新复制101；
}
}

• 参数使用的就近原则：

​ 1.方法中需要访问一个变量，会先从局部位置找该变量，找到就使用；找不到则去成员位置找同名变量。

​ 2.方法的内部和形参都属于局部位置，成员位置即成员变量的位置。

public class MyTest {
public static void main(String[] args) {
//一个Java文件中，可以定义多个类，有什么注意的，注意 public 只能在一个有main方法的类可以加上，其他类不能加public
Dog dog = new Dog();
do
4000
g.show();
dog.show1();
dog.show2("John");
}
}
class Dog {
String name = "小花";//成员位置
public void show() {//方法的内部和形参都属于局部位置
String name="lily";
System.out.println(name);//优先使用局部变量，这里打印的是lily
}
public void show1() {//方法的内部和形参都属于局部位置
System.out.println(name);//由于局部位置没有该变量，因此使用成员位置上的该同名变量这里打印的是小花
}
public void show2(String name) {//方法的内部和形参都属于局部位置
System.out.println(name);//优先使用形参传递过来的局部变量，因此这里打印John
System.out.println(this.name);//this关键字，对当前类的对象引用，打印结果为小花
}
}

• this关键字:this代表本类的一个引用，可理解为本类的一个对象。哪个对象调用某个方法，那么方法中的this就代表这个对象

public class MyTest {
public static void main(String[] args) {
A a = new A();
System.out.println(a);//1.地址值
int num=10;
a.show(num,a);//调用show方法，show方法结束后，弹栈。引用空间保留一段时间，直到main{}中不再调用该空间下的变量，java对该空间进行进行回收。
System.out.println(num); //6.打印栈内存中的局部变量num，值为10
}
}

class A{
int num=100;
public void show(int num, A a){
System.out.println(this);//2.地址值
System.out.println(num); //3.10
System.out.println(a.num); //4.打印本类中的num变量值100
System.out.println(this.num);//5.打印本类中的num变量值100
System.out.println(a==this);//6.判断this和对象a的地址值是否一致，结果为true
}
}

05 匿名对象

• 匿名对象：顾名思义，没有名字的对象。
• 应用场景1：调用方法，仅仅只调用一次的时候。

public class StudentPractice04 {
public static void main(String[] args) {
new Student();//匿名对象
int age = new Student().age;//匿名对象调用成员变量，每new一次就产生一个新的对象
System.out.println("age");
new Student().homeWork();//匿名对象的方法调用，每new一次就产生一个新的对象
}
}
class Student {
String name="Stephen";
int age=100;
public void homeWork(){
System.out.println("Do homework");
}
public void sleep(){
System.out.println("Go sleep");
}
}

• 应用场景2：匿名方法可以作为参数传递，但只能调用一次。

public class CatTest {
public static void main(String[] args) {
Cat cat = new Cat();
cat.show(cat, 19);
System.out.println(cat.num);//19
System.out.println("---------------------");
cat.show(new Cat(), 20);//匿名对象可以作为参数传递
System.out.println(cat.num);//匿名对象可以作为参数传递，但只能调用一次。因此此时打印的是前一个对象的成员变量值19
}
}
class Cat {
int num = 100;
public void show(Cat cat, int num) {
cat.num = num;
System.out.println(cat.num);
}
}
运行结果：19
19
---------------------
20
19

06 封装（private关键字）

• 概念：隐藏对象的属性和实现细节，仅对外提供公共访问方式。

• 原则：1.将不需要对外提供的内容都隐藏起来。
  2.把属性隐藏，提供公共方法对其访问。

• 封装的优势：1.隐藏实现细节，提供公共的访问方式
  2.提高了代码的复用性
  3.提高安全性。

• private关键字：1.是一个权限修饰符
  2.可以修饰成员变量和成员方法
  3.被其修饰的成员只能在本类中被访问

• private 是一个权限修饰符 可以修饰成员变量和成员方法，但是不可以修饰类，被修饰后，只能在本类中访问，外界无法访问。

• public 公共的 是一个权限修饰符 可以修饰类，成员变量和成员方法，被修饰的成员在任何地方都可以被访问

• 成员变量私有化后，如果想要对成员变量赋值，需要调用公共的set方法以及get方法

• 一键生成get setalt+insert自动生成get set 方法

• 程序示例：

public class MyTest {
public static void main(String[] args) {
Person person = new Person();
person.name="张三";//通过 对象名.成员变量名=值 这种方式给被public修饰的成员变量赋值
// person.age=23;私有化的成员变量，外界不能通过该方式直接进行赋值。
person.setAge(10);//私有化的成员变量需要调用公共的set方法进行赋值
System.out.println(person.name);
int age = person.getAge();//私有化的成员变量需要调用公共的get方法进行访问
System.out.println(age);
System.out.println("---------------------------");
Person person2 = new Person();
person2.name = "李四";
person2.setAge(40);
person2.show();
}
}
class Person {
String name;
private int age;//private 是一个权限修饰符，私有的，可以修饰成员变量，成员方法，被修饰的成员，只能在本类中访问，外界无法访问。
public void setAge(int age){
if(age>=0&&age<=100){
this.age = age;//使用关键字this可以区分形参中的同名变量
}else{
System.out.println("设置的年龄不合理");
}
}
public int getAge(){
return age;
}
public void show() {
System.out.println(name);
System.out.println(age);
}
}
运行结果：张三
10
---------------------------
李四
40