No_16_0226 Java基础学习第七天

文档版本 开发工具 测试平台 工程名字 日期 作者 备注
V1.0 2016.02.26 lutianfei none

成员变量与局部变量
形式参数问题
匿名对象
封装概述
private关键字
this关键字
构造方法
一个基本类的标准代码写法
Student s = new Student();在内存中做了哪些事情?
static关键字
静态变量和成员变量的区别
main方法是静态的

成员变量与局部变量

  • 成员变量与局部变量区别：
    • A：在类中的位置不同
      • 成员变量：在类中，方法外
      • 局部变量：在方法定义中或者方法声明上。
    • B:在内存中的位置不同：
      • 成员变量：在堆内存
      • 局部变量：在栈内存
    • C:生命周期不同
      • 成员变量：随着对象的创建而存在，随着对象的消失而消失
      • 局部变量：随着方法的调用而存在，随着方法的调用完毕而存在
    • D:初始化值不同
      • 成员变量：有默认初始值
      • 局部变量：没有默认初始值，必须定义，赋值，然后才能使用。
  • 注：局部变量名称可以和成员变量名称一致，在方法中使用的时候，采用就近原则。

形式参数问题

  • 一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
  1. //形式参数是 基本类型
  2. class Demo {
  3.     public int sum(int a,int b) {
  4.         return a + b;
  5.     }
  6. }
  8. //形式参数是 引用类型
  9. class Student {
  10.     public void show() {
  11.         System.out.println("我爱学习");
  12.     }
  13. }
  15. class StudentDemo {
  16.     //如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
  17.     public void method(Student s) { 
  18.     //调用的时候，把main方法中的s的地址传递到了这里 Student s = new Student();
  19.         s.show();
  20.     }
  21. }
  23. class ArgsTest {
  24.     public static void main(String[] args) {
  25.         //形式参数是基本类型的调用
  26.         Demo d = new Demo();
  27.         int result = d.sum(10,20);
  28.         System.out.println("result:"+result);
  29.         System.out.println("--------------");
  31.         //形式参数是引用类型的调用
  32.         //需求：我要调用StudentDemo类中的method()方法
  33.         StudentDemo sd = new StudentDemo();
  34.         //创建学生对象
  35.         Student s = new Student();
  36.         sd.method(s); //把s的地址给到了这里
  37.     }
  38. }

匿名对象

  • 匿名对象：就是没有名字的对象。
    • 是对象的一种简化表示形式
  • 匿名对象的两种使用情况
    • 对象调用方法仅仅一次的时候
    • 作为实际参数传递
  • 匿名调用好处
    • 匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
  1. class Student {
  2.     public void show() {
  3.         System.out.println("我爱学习");
  4.     }
  5. }
  7. class StudentDemo {
  8.     public void method(Student s) {
  9.         s.show();
  10.     }
  11. }
  13. class NoNameDemo {
  14.     public static void main(String[] args) {
  15.         //带名字的调用
  16.         Student s = new Student();
  17.         s.show();
  18.         s.show();
  19.         System.out.println("--------------");
  21.         //匿名对象
  22.         //new Student();
  23.         //匿名对象调用方法
  24.         new Student().show();
  25.         new Student().show(); //这里其实是重新创建了一个新的对象
  26.         System.out.println("--------------");
  28.         //匿名对象作为实际参数传递
  29.         StudentDemo sd = new StudentDemo();
  30.         //匿名对象
  31.         sd.method(new Student());
  33.         //再来一个
  34.         new StudentDemo().method(new Student());
  35.      }
  36. }


封装概述

  • 封装概述
    • 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
  • 好处：
    • 隐藏实现细节，提供公共的访问方式
    • 提高了代码的复用性
    • 提高安全性。
  • 封装原则：
    • 将不需要对外提供的内容都隐藏起来。
    • 把属性隐藏，提供公共方法对其访问。
  • 注：
    • 测试类一般只创建对象，调用方法。

private关键字

  • private关键字：

    • 是一个权限修饰符,是封装的一种体现。
    • 可以修饰成员(成员变量和成员方法)
    • 被private修饰的成员只在本类中才能访问。

  • private最常见的应用：

    • 把成员变量用private修饰
    • 提供对应的getXxx()/setXxx()方法
    • 一个标准的案例的使用

this关键字

  • this:代表所在类的对象引用
  • 记住：
    • 方法被哪个对象调用，this就代表那个对象
  1. class Student {
  2.     //姓名
  3.     private String name;
  4.     //年龄
  5.     private int age;
  7.     //姓名获取值
  8.     public String getName() {
  9.         return name;
  10.     }
  12.     //姓名设置值
  13.     public void setName(String name) { //name = "林青霞";
  14.         //Student.name = name;
  15.         this.name = name;
  16.     }
  18.     //年龄获取值
  19.     public int getAge() {
  20.         return age;
  21.     }
  23.     //年龄赋值
  24.     public void setAge(int age) {
  25.         this.age = age;
  26.     }
  27. }
  29. //测试类
  30. class StudentTest {
  31.     public static void main(String[] args) {
  32.         //创建学生对象
  33.         Student s = new Student();
  35.         //给成员变量赋值
  36.         s.setName("林青霞");
  37.         s.setAge(27);
  38.         //获取数据
  39.         System.out.println(s.getName()+"---"+s.getAge());
  40.     }
  41. }

构造方法

  • 构造方法作用概述
    • 给对象的数据进行初始化
  • 构造方法格式
    • 方法名与类名相同
    • 没有返回值类型，连void都没有
    • 没有具体的返回值。(可以有return；这一语句，表示方法到这里结束)
  • 构造方法注意事项
    • 如果你不提供构造方法，系统会给出默认无参构造方法
    • 如果你提供了构造方法，系统将不再提供默认的无参构造方法。必须自己给出。（建议永远自己给出无参构造方法！）
    • 构造方法也是可以重载的
  1. class Student {
  2.     private String name;
  3.     private int age;
  5.     public Student() {
  6.         System.out.println("这是无参构造方法");
  7.     }
  9.     //构造方法的重载格式
  10.     public Student(String name) {
  11.         System.out.println("这是带一个String类型的构造方法");
  12.         this.name = name;
  13.     }
  15.     public Student(int age) {
  16.         System.out.println("这是带一个int类型的构造方法");
  17.         this.age = age;
  18.     }
  20.     public Student(String name,int age) {
  21.         System.out.println("这是一个带多个参数的构造方法");
  22.         this.name = name;
  23.         this.age = age;
  24.     }
  26.     public void show() {
  27.         System.out.println(name+"---"+age);
  28.     }
  29. }
  31. class ConstructDemo2 {
  32.     public static void main(String[] args) {
  33.         //创建对象
  34.         Student s = new Student();
  35.         s.show();
  36.         System.out.println("-------------");
  38.         //创建对象2
  39.         Student s2 = new Student("林青霞");
  40.         s2.show();
  41.         System.out.println("-------------");
  43.         //创建对象3
  44.         Student s3 = new Student(27);
  45.         s3.show();
  46.         System.out.println("-------------");
  48.         //创建对象4
  49.         Student s4 = new Student("林青霞",27);
  50.         s4.show();
  51.     }
  52. }


一个基本类的标准代码写法

  • 类
    • 成员变量
    • 构造方法
      • 无参构造方法
      • 带参构造方法
    • 成员方法
      • getXxx()
      • setXxx()
  • 给成员变量赋值的方式
    • 无参构造方法+setXxx()
    • 带参构造方法
  1. /*
  2.     一个标准代码的最终版。
  4.     学生类：
  5.         成员变量：
  6.             name，age
  7.         构造方法：
  8.             无参，带两个参
  9.         成员方法：
  10.             getXxx()/setXxx()
  11.             show()：输出该类的所有成员变量值
  13.     给成员变量赋值：
  14.         A:setXxx()方法
  15.         B:构造方法
  17.     输出成员变量值的方式：
  18.         A:通过getXxx()分别获取然后拼接
  19.         B:通过调用show()方法搞定
  20. */
  21. class Student {
  22.     //姓名
  23.     private String name;
  24.     //年龄
  25.     private int age;
  27.     //构造方法
  28.     public Student() {
  29.     }
  31.     public Student(String name,int age) {
  32.         this.name = name;
  33.         this.age = age;
  34.     }
  36.     public String getName() {
  37.         return name;
  38.     }
  40.     public void setName(String name) {
  41.         this.name = name;
  42.     }
  44.     public int getAge() {
  45.         return age;
  46.     }
  48.     public void setAge(int age) {
  49.         this.age = age;
  50.     }
  52.     //输出所有的成员变量值
  53.     public void show() {
  54.         System.out.println(name+"---"+age);
  55.     }
  56. }
  58. //测试类
  59. class StudentTest {
  60.     public static void main(String[] args) {
  61.         //方式1给成员变量赋值
  62.         //无参构造+setXxx()
  63.         Student s1 = new Student();
  64.         s1.setName("林青霞");
  65.         s1.setAge(27);
  66.         //输出值
  67.         System.out.println(s1.getName()+"---"+s1.getAge());
  68.         s1.show();
  69.         System.out.println("----------------------------");
  71.         //方式2给成员变量赋值
  72.         Student s2 = new Student("刘意",30);
  73.         System.out.println(s2.getName()+"---"+s2.getAge());
  74.         s2.show();
  75.     }
  76. }


Student s = new Student();在内存中做了哪些事情?

  • 加载Student.class文件进内存
  • 在栈内存为s开辟空间
  • 在堆内存为学生对象开辟空间
  • 对学生对象的成员变量进行默认初始化
  • 对学生对象的成员变量进行显示初始化
  • 通过构造方法对学生对象的成员变量赋值
  • 学生对象初始化完毕，把对象地址赋值给s变量


static关键字

  • 可以修饰成员变量和成员方法
  • static关键字特点
    • 随着类的加载而加载
    • 优先于对象存在
    • 被类的所有对象共享
      • 这也是我们判断是否使用静态关键字的条件
    • 可以通过类名调用,也可以通过对象调用。
  • static关键字注意事项
    • 在静态方法中是没有this关键字的（无法从静态上下文引用非静态 变量 xxx）
      • 因为静态时随着类的加载而加载，this是随着对象的创建而存在。
      • 静态比对象先存在。
    • 静态方法只能访问静态的成员变量和静态的成员方法，非静态方法可以随意访问。

  1. class Teacher {
  2.     public int num = 10;
  3.     public static int num2 = 20;
  5.     public void show() {
  6.         System.out.println(num); //隐含的告诉你访问的是成员变量
  7.         System.out.println(this.num); //明确的告诉你访问的是成员变量
  8.         System.out.println(num2);
  10.     }
  12.     public static void method() {
  13.         //无法从静态上下文中引用非静态 变量 num
  14.         //System.out.println(num);
  15.         System.out.println(num2);
  17.         //无法从静态上下文中引用非静态 方法 function()
  18.         //function();
  19.         function2();
  20.     }
  22.     public void function() {
  24.     }
  26.     public static void function2() {
  28.     }
  29. }
  31. class TeacherDemo {
  32.     public static void main(String[] args) {
  33.         //创建对象
  34.         Teacher t = new Teacher();
  35.         t.show();
  36.         System.out.println("------------");
  37.         t.method();
  38.     }
  39. }


静态变量和成员变量的区别

  • 所属不同
    • 静态变量属于类，所以也称为为类变量
    • 成员变量属于对象，所以也称为实例变量(对象变量)
  • 内存中位置不同
    • 静态变量存储于方法区的静态区
    • 成员变量存储于堆内存
  • 内存出现时间不同
    • 静态变量随着类的加载而加载，随着类的消失而消失
    • 成员变量随着对象的创建而存在，随着对象的消失而消失
  • 调用不同
    • 静态变量可以通过类名调用，也可以通过对象调用
    • 成员变量只能通过对象名调用

main方法是静态的

  • public static void main(String[] args) {}
    • public 公共的，访问权限最大，因为被jvm调用，需要访问权限足够大。
    • static 静态的，不需要创建对象，被jvm调用，不用创建对象，直接类名访问
    • void被jvm调用，不需要给jvm返回值
    • main 一个通用的名称，虽然不是关键字，但是被jvm识别
    • String[] args 以前用于接收键盘录入的
      • eg：java MainDemo hello world java




posted @ 2016-02-28 17:10  鹿天斐  阅读(176)  评论(0)  编辑  收藏  举报