面向对象02
2018-11-09 本文已影响36人
丫甘九
成员变量和局部变量的区别
1、在类中的位置不同
- 成员变量 类中方法外
- 局部变量 方法内或者方法声明上
2、在内存中的位置不同
- 成员变量 堆内存
- 局部变量 栈内存
（局部变量：在方法定义中或者方法声明上的变量都称为局部变量）
注：
java程序为了提高程序的效率，就对数据进行了不同空间的分配，具体的是划分了如下几个空间
栈：存放的是局部变量
堆：存放的是所有new出来的东西
（堆内存的特点：
A 每一个new出来的对象都有地址值
B 每个变量都有默认值
byte int short long 0
float double 0.0
char \u000
boolean true false
引用类型 null
C 使用完毕就变成了垃圾，但不会立即回收，会在垃圾回收器空闲的时候回收 ）
方法区：专门存放方法的地方
本地方法区（和系统有关）：
寄存器：（CPU使用）
QQ图片20181109191131.png
3、生命周期不同
- 成员变量 随着对象的存在而存在，随着对象的消失而消失
- 局部变量 随着方法的调用而存在，随着方法的调用完毕而消失
4、初始值不同
- 成员变量 有默认的初始值
- 局部变量 没有默认的初始值，只能先定义，赋值才能使用
package mianxiangduixaing02;
/*成员变量和局部变量的区别
A 在类中的位置不同
成员变量 类中方法外
局部变量 方法内或者方法声明上
B 在内存中的位置不同
成员变量 堆内存
局部变量 栈内存
C 生命周期不同
成员变量 随着对象的存在而存在，随着对象的消失而消失
局部变量 随着方法的调用而存在，随着方法的调用完毕而消失
D 初始值不同
成员变量 有默认的初始值
局部变量 没有默认的初始值，只能先定义，赋值才能使用
*/
public class Variable {
//成员变量
int num = 10;
public void show(){
//局部变量
int num2=20;
}
}
package mianxiangduixaing02;
public class variabledemo {
//不同方法中是不能访问另一个方法内的变量
public static void main(String[] args){
Variable v = new Variable();
System.out.println(v.num);//访问成员变量
}
}
结果为10
public static void main(String[] args){
Variable v = new Variable();
System.out.println(v.num2);//访问局部变量error
//只能访问成员变量，访问局部变量会报错
}
}
public class Variable {
//成员变量
int num;//不给num赋值
public void show(){
//局部变量
//int num2; 不给num2赋值,就没有默认初始值
int num2 = 20;
System.out.println(num2);
}
}
public static void main(String[] args){
Variable v = new Variable();
System.out.println(v.num);//访问成员变量
v.show();//访问show方法
}
}
结果为10、20
方法的形式参数是类名的时候如何调用
什么是形式参数，什么是实际参数？？？
- 形式参数：就是在定义函数或过程的时候命名的参数。通俗讲就是一个记号。
- 实际参数：就是在执行时，调用函数或过程时，传递给函数或过程的参数。通俗讲就是实际值。
- 参数嘛，就是一个可变量，它随着使用者的不同而发生变化。举个例子，在中学的时候学过sin(x)函数，这里的x就是形式参数，当你需要求1的正弦值时，你会使用sin(1)，这里的1就是实际参数。
- 形参和实参间的关系：两者是在调用的时候进行结合的，通常实参会将取值
什么是基本类型，什么是引用类型？？？
java中的数据类型分为两大类：基本数据类型和引用数据类型
基本数据类型，包括数值型，字符型和布尔型。
-
数值型：1）整型：byte 1个字节；short 2个字节；int 4个字节；long 8个字节。
-
浮点型：float 4个字节;double
8个字节；可以采用十进制和十六进制两种表示方式，其中十六进制表示方法只能采用科学计数法，例如：0x1.2p3，表示的是的是1乘以16加上2乘以16的-1次方的和乘以2的三次方；浮点型的默认类型为DOUBLE型，如果声明float型浮点数，要在数值后面加上f或F，例如：float
f1 = 3.14F;否则会报精度错误。 -
字符型：char 采用unicod的16位编码方式进行编码。
-
布尔型：true,false;
引用数据类型：类、接口类型、数组类型、枚举类型、注解类型；
基本数据类型和引用数据类型的区别主要在存储方式上：
-
基本数据类型在被创建时，在栈上给其划分一块内存，将数值直接存储在栈上；
-
引用数据类型在被床架时，首先要在栈上给其引用（句柄）分配一块内存，而对象的具体信息都存储在堆内存上，然后由栈上面的引用指向堆中对象的地址。
形式参数的问题
- 基本类型：形式参数的改变不影响实际参数
- 引用类型：形式参数的改变直接影响实际参数
例1：形式参数是基本类型时
package mianxiangduixaing02;
public class xingshicanshu{
public int sum(int a,int b)//形式参数，参数是基本类型
{
return a+b;
}
}
package mianxiangduixaing02;
public class xingshicanshudemo {
public static void main(String[] args) {
xingshicanshu x = new xingshicanshu();
//x.sum(10, 20); 无结果，会报错，不能直接调用
//为什么不能直接调用？？
int result = x.sum(10, 20);
System.out.println("result:"+result);
}
}
结果为30
例2：形式参数是引用类型时
package mianxiangduixaing02;
public class student {
public void show() {
System.out.println("我爱学习");
}
}
package mianxiangduixaing02;
public class studentdemo {
//如果看到一个方法的形式参数是一个类类型（引用类型）,这里其实需要的就是该类的对象
public void method(student s)//形式参数是引用类型
{//调用的时候，把main方法中的地址传递到了这里 student s = new student()
s.show();
}
}
package mianxiangduixaing02;
public class test {
public static void main(String[] args) {
//形式参数是引用类型时的调用
//需求：调用studentdemo类中的method方法
studentdemo sd = new studentdemo();
//创建学生对象
student s = new student();
sd.method(s);//把s的地址值给到了这里
}
}
结果为“我爱学习”
匿名对象的概述和应用
匿名对像：
就是没有名字的对象（是对象的一种简化表达形式）
匿名对像的俩种使用情况：
对象调用方法仅仅是一次的时候
作为实际参数传参的时候
package mianxiangduixaing02;
public class test {
public static void main(String[] args) {
//形式参数是引用类型时的调用
//需求：调用studentdemo类中的method方法
studentdemo sd = new studentdemo();
//创建学生对象
student s = new student();
sd.method(s);//把s的地址值给到了这里
//匿名对像
new student();//只是创建出一个对象，并没有调用，所以不出结果值
//匿名对像调用方法
new student().show();
System.out.println("-----------------");
//为什么仅仅只能调用一次？
sd.method(s);
sd.method(s);//这表示同一个对象调用了俩次方法
new student().show();
new student().show();//这表示重新创建了一个对象,所以多次调用的时候不适合
}
}
结果为：
我爱学习
我爱学习
-----------------
我爱学习
我爱学习
我爱学习
我爱学习
匿名对像调用的好处是什么？
A 匿名对像调用完毕后就是垃圾，可以被垃圾回收站回收
B 匿名对像可以作为实际参数传递
//匿名对像可以作为实际参数传递
sd.method(new student());
结果为：我爱学习
private关键字的概述和特点
封装概述
- 是指隐藏对象的属性和实现细节，仅对外提供公共的访问方式
好处
- 隐藏实现细节，提供公共访问方式
- 提高了代码的复用性
- 提高安全性
封装原则
- 将不需要对外提供的内容都隐藏起来
- 把属性隐藏，提供公共方法对其访问
private关键字
- 是一个权限修饰符（只有自己可以访问）
- 可以修饰成员（成员变量和成员方法）
- 被private修饰的成员只能在本类中被访问
private最常见的应用
- 把成员变量用private修饰
- 提供对应的getxxx（）和ssetxxx（）方法
被private修饰后权限很小，只能自己访问
案例
package mianxiangduixaing02;
public class privatedemo {
//int num = 10;(1)
private int num = 20;//(2)
public void show(){
System.out.println(num);
}
private void method(){
System.out.println("method");
}
public void show2(){
method();
}
}
package mianxiangduixaing02;
public class privatetest {
public static void main(String[] args) {
privatedemo pd = new privatedemo();
//System.out.println(pd.num);(1)
pd.show();//(2)
pd.show2();
}
}
num第一种定义为int类，测试类中可以直接访问num，得出结果10
num第二种定义为private类，测试类中不可以直接访问，在privatedemo类中定义了一个公共的show方法，
然后在此方法中输出被定义为private类的num，在测试类中创建的对象调用show方法，得出结果20，
同理，被private修饰的方法也不能被直接调用，必须用同类中的一个公共的方法输出这个方法，
然后在测试类中调用这个公共的方法，结果为method
封装和private应用标准案例
package mianxiangduixaing02;
public 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 m){
age = m;
}
}
package mianxiangduixaing02;
public class studenttest {
public static void main(String[] args) {
student s = new student();
//System.out.println(s.Name+"---------"s.get);error
System.out.println(s.getName()+"--------"+s.getAge());
//给成员变量赋值
//s.Name="李四";error
//s.age="27";error
//通过方法赋值
s.setName("李四");
s.setAge(27);
System.out.println(s.getName()+"-------"+s.getAge());
}
}
结果为：null--------0
李四-------27
getXxx（）方法为获取，只能输出结果，setXxx（）方法为赋值，可以修改前面定义好的数值，也可以直接用此方法赋值
被private定义得无论是成员变量还是成员方法，都不可以被本类以外的类得到
this关键字的概述和应用
this关键字
- this：代表所在类的对象引用，简单说，代表当前类的一个对象
- 记住
方法被哪个对象调用，this就代表那个对象
什么时候使用this呢？？？
- 局部变量隐藏成员变量
- 其他用法见后面详解
案例
package mianxiangduixaing02;
//java中起名字要见名知意，单独的n，a拿出来别人并不知道是什么意思
public class student {
private String name;
private int age;
public String getName(){
return name;
}
/*public void setName(String n){
name= n;
}
*/
public void setName(String name){//name=李四
//name= name;
this.name=name;
}
//所以在这里将n改为name
//但是变量的使用规则是就近原则，所以这个是有问题的，结果出来为null 0
//这里的调用只能用对象名
//这个对象如果存在，它应该代表的就是student类中的一个对象
//那么谁能够代表当前的对象呢？java就提供了一个关键字 this
//this.name=name；
public int getAge(){
return age;
}
/*public void setAge(int m){
age = m;
}
*/
public void setAge(int age){
//age = age;
this.age=age;
}
//在这里将m改为age
}
package mianxiangduixaing02;
public class studenttest {
public static void main(String[] args) {
student s = new student();
//System.out.println(s.Name+"---------"s.get);error
System.out.println(s.getName()+"--------"+s.getAge());
//给成员变量赋值
//s.Name="李四";error
//s.age="27";error
//通过方法赋值
s.setName("李四");
s.setAge(27);
System.out.println(s.getName()+"-------"+s.getAge());
}
}
结果为：null--------0
李四-------27
this关键字的内存图解
package mianxiangduixaing02;
public class student1 {
private String name;
private int 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;
}
}
package mianxiangduixaing02;
public class student1test {
public static void main(String[] args) {
student1 s1 = new student1();//创建第一个对象
s1.setName("李美丽");
s1.setAge(27);
System.out.println(s1.getName()+"--------"+s1.getAge());
student1 s2 = new student1();//创建第二个对象
s2.setName("刘小花");
s2.setAge(18);
System.out.println(s2.getName()+"--------"+s2.getAge());
}
}
QQ图片20181111210239.png
注：首先，程序从main方法开始执行，创建第一个student1类的对象，然后对象调setName/setAge方法，程序走到student1类中的setName/setAge方法，将李美丽赋值给name（因为有形参，所以String name就相当于李美丽，this.name=String name=李美丽），然后程序走到类中方法外的成员变量name，当程序输出s1.getName()的时候，程序走到getName()方法，返回了name（此时的name就是刚才类中方法外的name），返回的name就输出了，结果为李美丽，其他同上
构造方法的概述与格式
构造方法作用概述
- 给对象的数据进行初始化
构造方法格式
- 方法名与类名相同
- 没有返回值类型，连void也没有（修饰符那一块没有任何东西）
- 没有具体的返回值（不需要用return来做什么东西）
构造方法的注意事项
- 如果你不提供构造方法，系统会给出默认的构造方法
- 如果你提供了构造方法，系统将不会再给出
- 构造方法也是可以重载的
构造方法的格式及作用案例
package mianxiangduixaing02;
public class construct {
private String name;//null
private int age;// 0
//系统自动给的初始值，所以构造方法的作用就是给成员变量赋默认值
public construct(){//这就是构造方法
System.out.println("这是一个构造方法");
}
}
package mianxiangduixaing02;
public class constructtest {
public static void main(String[] args) {
construct c = new construct();
char[] s = null;
System.out.println(s);//输出的是构造方法中的内容
}
}
构造方法的重载及注意事项
方法重载就是方法重写，构造方法重载就是将系统自带的构造方法重写
我们一直在使用构造方法，但是我们却没有定义过，那么构造方法从哪来呢？
- 构造方法的注意事项
- A 如果我们没有给出构造方法，系统将会自动提供一个无参构造方法
- B 如果我们给出了构造方法，系统将不会提供默认的构造方法
- 注：如果这个时候，我们还想用无参构造方法，就必须自己定义，建议自己定义无参构造方法
- 给成员赋值有俩种方法
- A setXxx（）方法
- B 构造方法
public class con
package mianxiangduixaing02;
struct {
private String name;
private int age;
public construct(){
System.out.println("这是无参构造方法");
}
public construct(String name){
System.out.println("这是带一个String类型的构造方法");
this.name = name;
}
public construct(int age){
System.out.println("这是带一个int类型的构造方法");
this.age = age;
}
public construct(String name,int age){
System.out.println("这是带一个String,int类型的构造方法");
this.name = name;
this.age = age;
}
public void show(){
System.out.println(name+"-------"+age);
}
}
package mianxiangduixaing02;
public class constructtest {
public static void main(String[] args) {
//创建对象1
construct c1 = new construct();
c1.show();
//创建对象2
construct c2 = new construct("李美丽");
c2.show();
//创建对象3
construct c3 = new construct(18);
c3.show();
//创建对象4
construct c4 = new construct("李美丽"+18);
c4.show();
}
}
结果为：
null-------0
这是带一个String类型的构造方法
李美丽-------0
这是带一个int类型的构造方法
null-------18
这是带一个String类型的构造方法
李美丽18-------0
成员方法的分类及使用
类的成员方法分类
根据返回值
- 有明确返回值类型
- 返回void类型的方法（无返回值类型）
根据形式参数
- 无参方法
- 带参方法
类的组成：成员变量、构造方法、成员方法
package mianxiangduixaing02;
public class student2 {
public String getString1(){//无参有返回值类型
return "hello1";
}
public void getString2(){//无参无返回值类型
System.out.println("hello2");
}
public String getString3(String name){//带参有返回值类型
return name;
}
public void getString4(String name){//带参无返回值类型
System.out.println(name);
}
}
package mianxiangduixaing02;
public class student2test {
public static void main(String[] args) {
student2 s= new student2();
//调用无参有返回值类型
String result = s.getString1();
System.out.println(result);
//调用无参无返回值类型
s.getString2();
//调用带参有返回值类型
String result2 = s.getString3("hello3");
System.out.println(result2);
//调用带参无返回值类型
s.getString4("hello4");
}
}
结果为：
hello1
hello2
hello3
hello4
创建对象时做了哪些事情
student s = new student();在内存中做了哪些事情？
- 加载student class文件进内存
- 在栈内存为s开辟内存空间
- 在堆内存为学生对象开辟内存空间
- 对学生对象的成员变量进行默认初始化
- 对学生对象的成员变量进行显示初始化
- 通过构造方法对学生对象的成员变量赋值
- 学生对象初始化完毕，把对象地址赋值给s变量
student 类案例及内存图解
package mianxiangduixaing02;
public class student3 {
private String name = "李美丽";//原本默认初始值为null
private int age = 27;//原本默认初始值为0
//在这里操作者手动给了值，name和age就变成了李美丽27//显示初始化
public student3(){//构造方法给成员变量赋值
name = "李四";
age = 30;
}
}
package mianxiangduixaing02;
public class student3test {
public static void main(String[] args) {
student3 s = new student3();
}
}
结果：李四 30
QQ图片20181112173254.png
static关键字的引入
static关键字
可以修饰成员变量和成员方法
static关键字的特点
- 随着类的加载而加载
（回想main方法，用static修饰的方法，如果class加载的时候没有加载main方法，我们使用的时候还能直接用么？不能，所以是随着类的加载而加载） - 优先于对象存在
（对象是在new的时候才出现，而它在class文件加载的时候就已经出现了） - 被类的所有成员共享（这也是我们判断是否使用关键字的条件，代码如下）
- 可以通过类名调用，其实她本身也可以通过对象名调用（推荐使用类名调用）
静态修饰的内容我们一般称其为：与类相关的，类成员
static:静态修饰成员变量（static怎么用），详细如下代码可见
public class person {
String name;
int age;
//String country;
static String country;
public person(){}
public person(String name,int age){
this.name = name;
this.age = age;
}
public person(String name,int age,String country){
this.name = name;
this.age = age;
this.country = country;
}
public void show(){
System.out.println("name="+name+"--------"+"age="+age+"-------"+"country="+country);
}
}
package mianxiangduixaing02;
public class persontest {
public static void main(String[] args) {
person p1 = new person("李美丽",16,"中国");
p1.show();
person p2 = new person("刘小花",18,"中国");
p2.show();
person p3 = new person("凤姐",27,"中国");
p3.show();
//三个人，名字和年龄都是不一样的，但是国籍都为中国，
//每new一次都开辟一次内存空间，太浪费内存了，所以java就提供了一个关键字 static
//用static修饰country
System.out.println("------------------------------------------------");
person p4 = new person("李美丽",16,"中国");
p4.show();
person p5 = new person("刘小花",18);
p5.show();
person p6 = new person("凤姐",27);
p6.show();
//在用static定义后，这里只给了p4国籍，其他俩个都没给
//结果和上面一样，都有三个变量显示
System.out.println("-----------------------------------------------");
p6.country="美国";
p6.show();
p4.show();
p5.show();
//结果都为美国，因为这些对象共享同一个静态修饰的成员
System.out.println(person.country); //通过类名调成员
}
}
结果为：
name=李美丽--------age=16-------country=中国
name=刘小花--------age=18-------country=中国
name=凤姐--------age=27-------country=中国
------------------------------------------------
name=李美丽--------age=16-------country=中国
name=刘小花--------age=18-------country=中国
name=凤姐--------age=27-------country=中国
-----------------------------------------------
name=凤姐--------age=27-------country=美国
name=李美丽--------age=16-------country=美国
name=刘小花--------age=18-------country=美国
美国
static关键字的注意事项
- 在静态方法中是没有this关键字的
- 静态方法只能访问静态的成员变量和静态的成员方法
案例代码如下
package mianxiangduixaing02;
//static 关键字注意事项
//A 在静态方法中是没有this关键字的 如何理解呢？？？
//静态是随着类的加载而加载，this是随着对象的创建而存在
//静态比对象先存在
//B 静态方法只能访问静态的成员变量和静态的成员方法
//静态方法
//成员变量：只能访问静态的成员变量
//成员方法：只能访问静态的成员方法
//非静态方法
//成员变量：可能是静态的，也可能是非静态的
//成员方法：可能是静态
public 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(){
//System.out.println(num);//error,无法从静态上下文中引用非静态
System.out.println(num2);
}
public void function(){
}
public static void function2(){
}
}
package mianxiangduixaing02;
public class Teachertest {
public static void main(String[] args) {
Teacher t = new Teacher();
t.show();
t.method();
}
}
结果为：
10
10
20
20
静态变量和成员变量的区别
所属不同
- 静态变量属于类，所以也称为类变量
- 成员变量属于对象，所以也称为实例变量（对象变量）
内存中的位置不同
- 静态变量存储于方法区的静态区
- 成员变量存储于堆内存
内存出现的时间不同
- 静态变量随着类的加载而加载，随着类的消失而消失
- 成员变量随着对象的创建而存在，随着对象的消失而消失
调用不同
- 静态变量可以通过类名调用，也可以通过对象调用
- 成员变量只能通过对象名调用
