Java学习笔记(6)【面向对象入门/成员变量与局部变量的区别/参数问题/封装匿名对象】

---

提示：以下是本篇文章正文内容，下面案例可供参考

Day10

1.什么是面向对象

面向对象基于面向过程的,思想特点
1)更符号我们说中的思想行为习惯
2)让复杂的事情简单化
3)我们从执行者变成了指挥者(角色发生了变化)
不断的去创建对象,使用对象,指挥对象做事情

2.面向对象的三大特征

封装,继承,多态

封装:
将一个事务的属性私有化,加入private关键字,对外保证安全性,仅限当前类访问,超过当前类不能直接访问
对外提供公共的setXXX()/getXXX()访问方法!(将属性隐藏了)

3.什么是类?类和事物的关系,什么是对象?

类是Java中最基本的单元,类是描述一组事物的属性和行为的集合!
和事物之间 关系:一一对应(程序中描述真实存在的现实世界的事物)
对象:对应的是具体的事物,描述具体的某个人/某个事物它的属性信息以及它的行为信息(做什么,张三学生–>学习英语…)
对象—需要在代码中实现:
类名 对象名 = new 类名() ;

4.如何创建一个类的对象?

类名 对象名 = new 类名() ; 创建一个有名字的对象

5.目前学习的类,那么类的成员目前有哪些?

成员变量—>就是描述事物的属性
类中,方法外
成员方法—>就是描述事物的行为的
去掉了static

Day11

1.成员变量与局部变量的区别

1)面试题:在基础面向对象面试题中:问的频率特别高

1)书写位置不同:
		局部变量:在方法定义中或者方法声明上
		成员变量:在类中方法外(范围大)
2)内存中的位置不同:
		局部变量:在栈内存中
		成员变量:在堆内存中
3)生命周期不同:
		局部变量:随着方法调用而存在,随着方法调用结束而消失
		成员变量:随着对象的创建而存在(跟对象有关系:类名 对象名 = new 类名();)随着对象创建完毕等待GC空闲的时候回收掉,而消失!
4)初始化值不同:
		局部变量:要么先定义后初始化,要么直接初始化
				在使用之前必须初始化,否则报错"可能尚未初始化变量"
		成员变量:存在系统默认初始化值,可以不赋值,可以赋值,但是一般不会直接赋值(笔试题中可能出现,直接赋值)
					都是通过对象名.成员变量名 = 赋值 ;

2)成员变量与局部变量

//看程序 写结果

class ClassA{  //ClassA类型
    int value; //成员变量---堆内存中的---跟当前类的对象有关系  默认值就是0
}
public class TestClassA{
    public static void main(String args[]){
        int value = 10;//局部变量
        System.out.println(value) ; //10
        changeInt(value);
        System.out.println(value);//10
        System.out.println("==================================");
        ClassA ca = new ClassA(); // 创建一个类的对象,系统对当前类的成员变量系统默认初始化
        ca.value = 10;  //显示初始化给直接赋值了10 ,使用当前ca对象(空间地址值引用)
        System.out.println(ca.value) ; //10
        changeObject(ca);//对象:空间地址值引用
        System.out.println(ca.value);//11
    }
    //形式参数是基本类型,形参的改变不影响实际参数,而且方法调用完毕,就消失了!
    //四类八种:基本数据类型:jvm不需要加载的,但是引用类型需要加载类的!
    public static void changeInt(int value){//10  //形式参数:基本数据类型,形参的改变不会实际参数
        value++; //11
        System.out.println(value);
    }

    //当前这个方法调用完毕,里面是对象(空间地址值),不会立即消失,等待垃圾回收掉的
    public static void changeObject(ClassA ca){//形式参数是一个引用类型,调用
                                //这个方法的时候,里面传递当前ClassA的类对象 --->ca 对象
        ca.value++;
                        //10++ = 11,引用类型,形式参数的改变直接影响实际参数(String除外!)
    }
}

2.方法形式参数问题(很重要,面试题)

① 形式参数是基本数据类型

​ 总结：
​ 如果是形式参数是基本数据类型传递的数据值，形式参数的改变不会影响实际参数！

​ String 是特殊的引用数据类型，作为形式参数，和基本数据类型的效果是一样的！

/*
	如果是基本数据类型/引用数据类型作为形参的区别
			看程序,写结果--考点(形式参数是基本数据类型,引用数据:数组)
		形式参数如果是基本数据类型,形参的改变不会影响实际参数
*/

public class Test {
    public static void main(String[] args) {

        //有两个变量
        int a = 10 ;
        int b = 20 ;

        System.out.println("a:"+a+",b:"+b) ;//10,20
        change(a,b) ;//实际参数
        System.out.println("----------------------") ;
        System.out.println("a:"+a+",b:"+b) ;//10,20
    }
    private static void change(int a, int b) { //形式参数是基本数据类型
        System.out.println("a:"+a+",b:"+b) ;//10,20
        a = b ;  //形参改变
        b = a+ b ;
        System.out.println("a:"+a+",b:"+b) ;//20,40
    }
}

② 形式参数是引用数据类型

总结：

​ 如果方法的形式参数是引用类型，形式参数的改变会影响实际参数，因为，引用数据类型—都是空间地址值传递！

public class Test2 {
    public static void main(String[] args) {

        //创建一个数组,静态初始化
        int[] arr = {1,2,3,4,5} ;

        System.out.println(arr[1]) ; //2
        change(arr) ;//实际参数传递----数组对象----new 东西  空间地址值
        System.out.println(arr[1]) ;//4
    }

    //形式参数是引用数据类型,数组
    public static void change(int[] arr) { //数组,引用数据类型 ---形式参数是数组类型---
        //遍历数组
        for(int x = 0 ; x < arr.length ; x ++){
            if(arr[x] % 2== 0){
                arr[x] *=2 ;
            }
        }
    }
}

③ 特殊的引用数据类型String

总结：

​ String是一种特殊的引用类型，他作为形式参数的效果和基本数据类型是一致的，形参的改变不会影响实际参数! 因为:String 是常量!

public class Test3 {
    public static void main(String[] args) {

        //定义一个字符串
        String str = "hello" ;
        System.out.println("str:"+str);//str:hello
        change(str) ;
        System.out.println("---------------------") ;
        System.out.println("str:"+str);//str:hello
    }

    //change方法
    public static void change(String str) { //形式参数是String类型
        System.out.println(str) ;//hello
        str += "高圆圆" ;
        System.out.println(str) ;//hello高圆圆
    }
}

④ 形式参数是类

总结:

​ 如果当前形式参数是类(引用数据类型),调用方法的时候,实际参数需要传递的是当前类的具体对象

​ 类名 对象名 = new 类名() ; 具体的对象名----就是那个空间地址值传递

//定义一个学生类
class Student{
    //成员方法
    public void study(){
        System.out.println("Good Good Study ,Day Day Up!!!");
    }
}
//StudentDemo类
class StudentDemo{
    //成员方法
    public void method(Student student){//形式参数Student类型,引用类型
        student.study() ;//什么才能访问学生类的study方法呢?
                        //学生对象才能访问study方法呀!!
                        //实际参数需要创建Student类对象才能访问study()
                        //下面的实际参数就是s---代表学生对象
                        //s.study() ;
    }
}

//测试类
public class StudentTest {
    public static void main(String[] args) {
        //需求:调用StudentDemo类中的method方法?如何访问呢?
        //1)创建StudentDemo类对象
        StudentDemo studentDemo = new StudentDemo() ;
        //一看到,当前method方法中有一个Student类型,所以需要创建Student类的对象
        Student s = new Student() ;
        studentDemo.method(s);//实际参数,形式参数是Student类型
    }
}

3.面向对象之封装

封装:

​ 就是将一个事物中的所有属性私有化 private ,保证其安全性(属性隐藏了)

​ 提供对外的公共访问Setxxx()/getxxx()访问

//set 放置,设置的意思
//get 获得,得到

public class Student {
    //成员变量:私有化
    private String name ; //姓名  系统默认初始化---然后通过setXXX赋值     
    private int age ;    //年龄                                           
    private String gender ;//性别                                         

    //提供对外的公共访问方法
    //成员方法:去掉static
    //一会需要赋值; setXXX方法
    public void setName(String n){ //"高圆圆"
        name = n ;   //"高圆圆"
    }
    //一会获取成员变量的值 getXXX方法
    public String getName(){
        return  name ;//"高圆圆"
    }

    //给年龄赋值
    public void setAge(int a){//42
        age = a ; //42
    }

    //获取年龄值
    public int getAge(){
        return age ;//42
    }

    //给性别赋值
    public void setGender(String g){
        gender = g ; //局部变量g 赋值给成员变量  "女"
    }
    //获取性别的值
    public String getGender(){
        return  gender ; //"女"
    }


    //学习(),玩游戏()
    public void study(){
        System.out.println("我们在学习JavaSE...");
    }
    public void playGame(String gameName){
        System.out.println("学习到周末,可以玩"+gameName+"放松一下");
    }

}

//测试类
public class StudentTest {
    //就是模拟数据---以后的数据都是从 mysql(市面上用的比较多的)数据库中获取的
    public static void main(String[] args) {

        //测试Student类
        //类名 对象名 = new 类名() ;
        Student s = new Student() ;
        //现在所有属性已经私有化
       // s.name = "高圆圆" ;
        //s.age = 20 ;
       // s.gender = "女" ;

      //  System.out.println(s.name+"---"+s.age+"---"+s.gender);

        //刚才手动给出了姓名,年龄,性别的setXXX()/getXXX()方法
        //所以现在测试
        //setXXX
        s.setName("高圆圆") ;
        s.setAge(42) ;
        s.setGender("女") ;

        //输出 :获取值getXXX
        System.out.println("学生的姓名是"+s.getName()+",年龄是:"+s.getAge()+",性别是:"+s.getGender());
        //调用其他的成员方法
        s.study();
        s.playGame("战地5");
    }
}

4.匿名对象

匿名对象:

​ 就是没有名字的对象!

一般通用格式:

​ 类名 对象名 = new 类名() ; 有名字的对象

1)匿名对象的格式:

​ new 类名() ; //不需要在栈内开辟空间,直接堆内存中申请空间

2)匿名的好处

​ ① 在实际开发中,匿名对象不要使用多次,使用一次即可!

​ 使用完毕后,立即就被垃圾回收器回收了(因为没有栈内存变量指向堆内存地址)

​ ② 匿名对象可以作为参数传递

​ ③ 匿名对象 从内存角度考虑 ,能够节省内存!

//老师类
class   Teacher{
    //成员方法
    public void love(){
        System.out.println("爱生活,爱Java,爱高圆圆!!");
    }
}
//定义TeacherDemo类
class TeacherDemo{
    //成员方法
    public void function(Teacher t){//形式参数是一个引用类型---老师类
        t.love() ;

        //Teacher teacher = new Teacher() ;teacher是实际参数
        //teacher.love() ;
    }
}

//测试类
public class NoNameDemo {
    public static void main(String[] args) {
        //要访问TeacherDemo类中的function方法? ,而且实际参数应该怎么传递
        //1)创建一个TeacherDemo类对象
        TeacherDemo td = new TeacherDemo() ;
        //观察:上面的function方法的形式参数是一个Teacher类型,需要传递实际参数:是Teacher类对象

        Teacher teacher = new Teacher() ;//空间地址值
        td.function(teacher) ;

        System.out.println("----------------------------------------");

        //使用匿名对象操作:
        //匿名对象的格式是什么: new 类名() ;
        //要访问TeacherDemo类中的function方法? ,而且实际参数应该怎么传递
        //1)创建一个TeacherDemo类对象
        TeacherDemo td2 = new TeacherDemo() ;
        td2.function(new Teacher());


        System.out.println("----------------------------------------");

        //继续优化:
        要访问TeacherDemo类中的function方法? ,而且实际参数应该怎么传递
        //链式编程(仅仅是自己玩一下可以,实际开发中,尽量明细步骤来!)
        new TeacherDemo().function(new Teacher());

    }
}

5.this关键字

Java中有一个规定

• 当局部变量隐藏了成员变量的时候,提供了一个关键字----叫"this",来区分成员变量和局部变量
• this:代表的是当前类对象的地址值引用!
• this.变量名---->变量名---->成员变量名 (对象.成员变量)

this()不能在普通方法中使用,只能写在构造方法中,而且在构造方法中使用,必须是第一条语句!