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

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();
        dog.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

猜你喜欢

转载自blog.csdn.net/yinyanyao1747/article/details/89206012
0条评论
添加一条新回复
  
今日推荐