No_16_0226 Java基础学习第七天
2016-02-28 17:10
393 查看
文档版本 | 开发工具 | 测试平台 | 工程名字 | 日期 | 作者 | 备注 |
---|---|---|---|---|---|---|
V1.0 | 2016.02.26 | lutianfei | none |
形式参数问题
匿名对象
封装概述
private关键字
this关键字
构造方法
一个基本类的标准代码写法
Student s = new Student();在内存中做了哪些事情?
static关键字
静态变量和成员变量的区别
main方法是静态的
成员变量与局部变量
成员变量与局部变量区别:A:在类中的位置不同
成员变量:在类中,方法外
局部变量:在方法定义中或者方法声明上。
B:在内存中的位置不同:
成员变量:在堆内存
局部变量:在栈内存
C:生命周期不同
成员变量:随着对象的创建而存在,随着对象的消失而消失
局部变量:随着方法的调用而存在,随着方法的调用完毕而存在
D:初始化值不同
成员变量:有默认初始值
局部变量:没有默认初始值,必须定义,赋值,然后才能使用。
注:局部变量名称可以和成员变量名称一致,在方法中使用的时候,采用就近原则。
形式参数问题
一个方法的形式参数是一个类类型(引用类型),这里其实需要的是该类的对象。//形式参数是 基本类型
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的地址给到了这里
}
}
[/code]
匿名对象
匿名对象:就是没有名字的对象。是对象的一种简化表示形式
匿名对象的两种使用情况
对象调用方法仅仅一次的时候
作为实际参数传递
匿名调用好处
匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
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());
}
}
[/code]
封装概述
封装概述是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。
好处:
隐藏实现细节,提供公共的访问方式
提高了代码的复用性
提高安全性。
封装原则:
将不需要对外提供的内容都隐藏起来。
把属性隐藏,提供公共方法对其访问。
注:
测试类一般只创建对象,调用方法。
private关键字
private关键字:是一个权限修饰符,是封装的一种体现。
可以修饰成员(成员变量和成员方法)
被private修饰的成员只在本类中才能访问。
private最常见的应用:
把成员变量用
private修饰
提供对应的getXxx()/setXxx()方法
一个标准的案例的使用
this关键字
this:代表所在类的对象引用
记住:
方法被哪个对象调用,this就代表那个对象
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());
}
}
[/code]
构造方法
构造方法作用概述给对象的数据进行初始化
构造方法格式
方法名与类名相同
没有返回值类型,连void都没有
没有具体的返回值。(可以有return;这一语句,表示方法到这里结束)
构造方法注意事项
如果你不提供构造方法,系统会给出默认无参构造方法
如果你提供了构造方法,系统将不再提供默认的无参构造方法。必须自己给出。(建议永远自己给出无参构造方法!)
构造方法也是可以重载的
class Student {
private String name;
private int age;
public Student() {
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("-------------");
//创建对象2
Student s2 = new Student("林青霞");
s2.show();
System.out.println("-------------");
//创建对象3
Student s3 = new Student(27);
s3.show();
System.out.println("-------------");
//创建对象4
Student s4 = new Student("林青霞",27);
s4.show();
}
}
[/code]
一个基本类的标准代码写法
类成员变量
构造方法
无参构造方法
带参构造方法
成员方法
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();
}
}
[/code]
Student s = new Student();在内存中做了哪些事情?
加载Student.class文件进内存在栈内存为s开辟空间
在堆内存为学生对象开辟空间
对学生对象的成员变量进行默认初始化
对学生对象的成员变量进行显示初始化
通过构造方法对学生对象的成员变量赋值
学生对象初始化完毕,把对象地址赋值给s变量
static关键字
可以修饰成员变量和成员方法static关键字特点
随着类的加载而加载
优先于对象存在
被类的所有对象共享
这也是我们判断是否使用静态关键字的条件
可以通过类名调用,也可以通过对象调用。
static关键字注意事项
在静态方法中是没有this关键字的(无法从静态上下文引用非静态 变量 xxx)
因为静态时随着类的加载而加载,
this是随着对象的创建而存在。
静态比对象先存在。
静态方法只能访问静态的
成员变量和静态的
成员方法,非静态方法可以随意访问。
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);
}
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();
}
}
[/code]
静态变量和成员变量的区别
所属不同静态变量属于类,所以也称为为类变量
成员变量属于对象,所以也称为实例变量(对象变量)
内存中位置不同
静态变量存储于方法区的静态区
成员变量存储于堆内存
内存出现时间不同
静态变量随着类的加载而加载,随着类的消失而消失
成员变量随着对象的创建而存在,随着对象的消失而消失
调用不同
静态变量可以通过类名调用,也可以通过对象调用
成员变量只能通过对象名调用
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)
相关文章推荐
- spring - ioc和aop
- 为什么jdk中把String类设计成final?
- java数组的增删改查
- java接口
- java反射学习笔记之 动态加载类
- JDK新特性
- Java 并发变成同步机制
- java--- Map详解
- 单例与序列化的那些事儿
- 华为机试题: 将数组中的字符串按指定长度重新分割(java)
- Java HashMap 核心源码解读
- Java中比较常用的两种数据转化
- 【Java】(三)运算符小结(比较、逻辑、三元运算符)
- Spring进阶之路(3)-bean获得Spring的容器
- Spring进阶之路(1)-Spring核心机制:依赖注入/控制反转
- 解决eclipse控制台中文乱码
- eclipse 阅读代码 快捷键
- java求百分比
- java基础笔记
- easyui+SpringMVC添加图片