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

其他 2019-04-16 21:35:21 阅读次数: 0

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
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022