No_16_0226 Java基础学习第七天
| 文档版本 | 开发工具 | 测试平台 | 工程名字 | 日期 | 作者 | 备注 |
|---|---|---|---|---|---|---|
| V1.0 | 2016.02.26 | lutianfei | none |
成员变量与局部变量
形式参数问题
匿名对象
封装概述
private关键字
this关键字
构造方法
一个基本类的标准代码写法
static关键字
静态变量和成员变量的区别
main方法是静态的
形式参数问题
匿名对象
封装概述
private关键字
this关键字
构造方法
一个基本类的标准代码写法
static关键字
静态变量和成员变量的区别
main方法是静态的
成员变量与局部变量
- 成员变量与局部变量区别：
- A：在类中的位置不同
- 成员变量：在类中，方法外
- 局部变量：在方法定义中或者方法声明上。
- B:在内存中的位置不同：
- 成员变量：在堆内存
- 局部变量：在栈内存
- C:生命周期不同
- 成员变量：随着对象的创建而存在，随着对象的消失而消失
- 局部变量：随着方法的调用而存在，随着方法的调用完毕而存在
- D:初始化值不同
- 成员变量：有默认初始值
- 局部变量：没有默认初始值，必须定义，赋值，然后才能使用。
- A：在类中的位置不同
- 注：局部变量名称可以和成员变量名称一致，在方法中使用的时候，采用就近原则。
class Varialbe {//成员变量//int num = 10;int num; //0public void show() {//int num2 = 20; //局部变量//可能尚未初始化变量num2//int num2; //没有默认值int num2 = 20;System.out.println(num2);//int num = 100;System.out.println(num);}}class VariableDemo {public static void main(String[] args) {Varialbe v = new Varialbe();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);System.out.println("--------------");//形式参数是引用类型的调用//需求：我要调用StudentDemo类中的method()方法StudentDemo sd = new StudentDemo();//创建学生对象Student s = new Student();sd.method(s); //把s的地址给到了这里}}
匿名对象
- 匿名对象：就是没有名字的对象。
- 是对象的一种简化表示形式
- 匿名对象的两种使用情况
- 对象调用方法仅仅一次的时候
- 作为实际参数传递
- 匿名调用好处
- 匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
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();s.show();System.out.println("--------------");//匿名对象//new Student();//匿名对象调用方法new Student().show();new Student().show(); //这里其实是重新创建了一个新的对象System.out.println("--------------");//匿名对象作为实际参数传递StudentDemo sd = new StudentDemo();//匿名对象sd.method(new Student());//再来一个new StudentDemo().method(new Student());}}
封装概述
- 封装概述
- 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
- 好处：
- 隐藏实现细节，提供公共的访问方式
- 提高了代码的复用性
- 提高安全性。
- 封装原则：
- 将不需要对外提供的内容都隐藏起来。
- 把属性隐藏，提供公共方法对其访问。
- 注：
- 测试类一般只创建对象，调用方法。
private关键字
private关键字：
- 是一个权限修饰符,是封装的一种体现。
- 可以修饰成员(成员变量和成员方法)
- 被private修饰的成员只在本类中才能访问。
private最常见的应用：
- 把成员变量用private修饰
- 提供对应的getXxx()/setXxx()方法
- 一个标准的案例的使用
class Student {//姓名private String name;//年龄private int age;//姓名获取值public String getName() {return name;}//姓名设置值public void setName(String n) {name = n;}//年龄获取值public int getAge() {return age;}//年龄赋值public void setAge(int a) {age = a;}}//测试类class StudentTest {public static void main(String[] args) {//创建学生对象Student s = new Student();//使用成员变量//错误：被私有修饰了，外界不能直接访问了//System.out.println(s.name+"---"+s.age);System.out.println(s.getName()+"---"+s.getAge());//给成员变量赋值//s.name = "林青霞";//s.age = 27;//通过方法给赋值s.setName("林青霞");s.setAge(27);System.out.println(s.getName()+"---"+s.getAge());}}
this关键字
- this:代表所在类的对象引用
- 记住：
- 方法被哪个对象调用，this就代表那个对象
- 什么时候使用this呢?
- 局部变量隐藏成员变量
- 其他用法后面和super一起讲解
class Student {//姓名private String name;//年龄private int age;//姓名获取值public String getName() {return name;}//姓名设置值public void setName(String name) { //name = "林青霞";//Student.name = name;this.name = name;}//年龄获取值public int getAge() {return age;}//年龄赋值public void setAge(int age) {this.age = age;}}//测试类class StudentTest {public static void main(String[] args) {//创建学生对象Student s = new Student();//给成员变量赋值s.setName("林青霞");s.setAge(27);//获取数据System.out.println(s.getName()+"---"+s.getAge());}}
构造方法
- 构造方法作用概述
- 给对象的数据进行初始化
- 构造方法格式
- 方法名与类名相同
- 没有返回值类型，连void都没有
- 没有具体的返回值。(可以有return；这一语句，表示方法到这里结束)
- 构造方法注意事项
- 如果你不提供构造方法，系统会给出默认无参构造方法
- 如果你提供了构造方法，系统将不再提供默认的无参构造方法。必须自己给出。（建议永远自己给出无参构造方法！）
- 构造方法也是可以重载的
class Student {private String name;private int age;public Student() {//System.out.println("我给了，你还给不");System.out.println("这是无参构造方法");}//构造方法的重载格式public Student(String name) {System.out.println("这是带一个String类型的构造方法");this.name = name;}public Student(int age) {System.out.println("这是带一个int类型的构造方法");this.age = age;}public Student(String name,int age) {System.out.println("这是一个带多个参数的构造方法");this.name = name;this.age = age;}public void show() {System.out.println(name+"---"+age);}}class ConstructDemo2 {public static void main(String[] args) {//创建对象Student s = new Student();s.show();System.out.println("-------------");//创建对象2Student s2 = new Student("林青霞");s2.show();System.out.println("-------------");//创建对象3Student s3 = new Student(27);s3.show();System.out.println("-------------");//创建对象4Student s4 = new Student("林青霞",27);s4.show();}}
一个基本类的标准代码写法
- 类
- 成员变量
- 构造方法
- 无参构造方法
- 带参构造方法
- 成员方法
- getXxx()
- setXxx()
- 给成员变量赋值的方式
- 无参构造方法+setXxx()
- 带参构造方法
/*一个标准代码的最终版。学生类：成员变量：name，age构造方法：无参，带两个参成员方法：getXxx()/setXxx()show()：输出该类的所有成员变量值给成员变量赋值：A:setXxx()方法B:构造方法输出成员变量值的方式：A:通过getXxx()分别获取然后拼接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 StudentTest {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();System.out.println("----------------------------");//方式2给成员变量赋值Student s2 = new Student("刘意",30);System.out.println(s2.getName()+"---"+s2.getAge());s2.show();}}
- Student s = new Student();在内存中做了哪些事情?
- 加载Student.class文件进内存
- 在栈内存为s开辟空间
- 在堆内存为学生对象开辟空间
- 对学生对象的成员变量进行默认初始化
- 对学生对象的成员变量进行显示初始化
- 通过构造方法对学生对象的成员变量赋值
- 学生对象初始化完毕，把对象地址赋值给s变量
static关键字
- 可以修饰成员变量和成员方法
- static关键字特点
- 随着类的加载而加载
- 优先于对象存在
- 被类的所有对象共享
- 这也是我们判断是否使用静态关键字的条件
- 可以通过类名调用,也可以通过对象调用。
- static关键字注意事项
- 在静态方法中是没有this关键字的（无法从静态上下文引用非静态 变量 xxx）
- 因为静态时随着类的加载而加载，this是随着对象的创建而存在。
- 静态比对象先存在。
- 静态方法只能访问静态的成员变量和静态的成员方法，非静态方法可以随意访问。
- 在静态方法中是没有this关键字的（无法从静态上下文引用非静态 变量 xxx）
class Teacher {public int num = 10;public static int num2 = 20;public void show() {System.out.println(num); //隐含的告诉你访问的是成员变量System.out.println(this.num); //明确的告诉你访问的是成员变量System.out.println(num2);//function();//function2();}public static void method() {//无法从静态上下文中引用非静态 变量 num//System.out.println(num);System.out.println(num2);//无法从静态上下文中引用非静态 方法 function()//function();function2();}public void function() {}public static void function2() {}}class TeacherDemo {public static void main(String[] args) {//创建对象Teacher t = new Teacher();t.show();System.out.println("------------");t.method();}}
静态变量和成员变量的区别
- 所属不同
- 静态变量属于类，所以也称为为类变量
- 成员变量属于对象，所以也称为实例变量(对象变量)
- 内存中位置不同
- 静态变量存储于方法区的静态区
- 成员变量存储于堆内存
- 内存出现时间不同
- 静态变量随着类的加载而加载，随着类的消失而消失
- 成员变量随着对象的创建而存在，随着对象的消失而消失
- 调用不同
- 静态变量可以通过类名调用，也可以通过对象调用
- 成员变量只能通过对象名调用
main方法是静态的
- public static void main(String[] args) {}
- public 公共的，访问权限最大，因为被jvm调用，需要访问权限足够大。
- static 静态的，不需要创建对象，被jvm调用，不用创建对象，直接类名访问
- void被jvm调用，不需要给jvm返回值
- main 一个通用的名称，虽然不是关键字，但是被jvm识别
- String[] args 以前用于接收键盘录入的
- eg：java MainDemo hello world java
来自为知笔记(Wiz)