Java学习笔记_03

局部变量和成员变量

写在类中的叫成员变量，写在方法中的是成员变量
区别：

定义位置不同
作用域不同
默认值不同
	成员变量有默认值
	局部变量没有默认值，未赋值不能使用
内存位置不同
	成员变量跟随对象进入堆内存
	局部变量跟随方法进入堆内存
生命周期不同
	成员变量跟随对象，内存等待JVM清理
	局部变量跟随方法，方法出栈，变量被清理

方法参数是基本数据类型和引用数据类型

方法参数是基本数据类型

// 视频9_10讲解
public class Car {
    public static void main(String[] args) {
        int a = 1;
        function(a);  // 函数执行完后函数中变量a已经被回收，并没有改变main函数中的a
        System.out.println(a);  // 输出1 
    }
    public static void function(int a) {
        a += 5;
    }
}

方法参数是引用数据类型

Person类

package cn.itcast.demo02;

public class Person {
    int age = 18;
}

main函数

package cn.itcast.demo02;

public class PersonTest {
    public static void main(String[] args) {
        Person P = new Person();
        System.out.println(P.age); // 输出18
        // 变量P指向对象P的内存空间
        function(P);
        System.out.println(P.age); // 输出20
    }
    public static void function(Person A) {
    	// 变量A指向对象P的内存空间
        A.age = 20;
    }
}

注：函数中传引用数据类型实际传的是内存地址，会导致数据改变，比如传数组和对象

封装

封装的表现

1.方法就是基本的封装体
2.类其实也是封装体

封装的好处

1.提高了代码的复用性
2.隐藏细节，便于调用
3.提高了安全性

private关键字

被private修饰的成员，只能在自己本类使用，不能在外类使用

可以在本类使用

package cn.itcast.demo02;

public class Person {
    int age = 18;
    private String gender = "man";

    public static void main(String[] args) {
        Person P = new Person();
        System.out.println(P.age);
        System.out.println(P.gender); // 可以使用，输出"man"
    }
}

不能在外类使用

package cn.itcast.demo02;

public class PersonTest {
    public static void main(String[] args) {
        Person P = new Person();
        System.out.println(P.age);
        System.out.println(P.man); // 无法访问，报错
    }
}

给私有方法提供对外接口

Person类

package cn.itcast.demo03;

public class Person {
    private int age;
    private String gender;

    public void setAge(int age) {
        this.age = age; // 重名，使用this关键字
    }

    public void setGender(String a) {
        gender = a; // 没有重名，可以不用this关键字
    }

    public String getGender() {
        return gender;
    }

    public int getAge() {
        return age;
    }

    public void speak() {
        System.out.println(age);
        System.out.println(gender);

    }
}

PersonTest类

package cn.itcast.demo03;

public class PersonTest {
    public static void main(String[] args) {
        Person P = new Person();
        P.setAge(23);
        P.setGender("man");
        System.out.println(P.getAge());
        System.out.println(P.getGender());
        P.speak();
    }
}

小结：类中不需要对外提供的属性都私有化，包括属性和方法
并提供set和get方法对其进行访问
注意：私有仅仅是对封装的体现而已

this 关键字

方法中的局部变量名如果和成员变量重名，该变量是局部变量。
如果方法中没有定义，则使用方法名。
注意：this表示本类对象，this关键字可以解决重名问题。相当于python中的self。

继承(先跳过)

// 格式
public class SmallCat extends Cat{}

接口编程

接口定义

package cn.itcast.demo04;

public interface MyInterface {
    // 抽象方法的定义：
    // 1.固定格式：public abstract 返回值类型 方法名字(参数列表)
    // 2.接口中均为公共访问的抽象方法，不写public会默认public
    // 3.接口中无法定义普通的成员变量

    // 接口中成员变量的定义
    // 1.必须是常量
    // 2.固定格式：public static final 数据类型 变量名 = 值


    public static final int a = 1;

    public abstract void function();
}

编写接口的实现类

package cn.itcast.demo04;

/*
    定义类，实现接口，重写接口中的抽象方法
    类实现接口，可以理解为继承
    关键字implements
    class 类 implempents 接口{
    重写接口中的抽象方法
    }
    public class 类 implements 接口
*/
public class MyInterfaceImp1 implements MyInterface{
    public void function(){
        System.out.println("实现类，重写接口的抽象方法");
    }
}

接口中成员的特点

package cn.itcast.demo04;

/*
    接口中成员的特点
    1.成员遍变量的特点，没有变量，都是常量
    2.固定定义格式：public static final 数据类型 变量 = 值
    3.public权限
    4.static 可以直接由接口名调用
    5.final 最终，可以固定变量的值
    注意：
    1.public static final 都属于修饰符，在接口的定义中可以省略不写，或选择性书写
    2.实现类，实现接口，必须重写接口全部抽象方法，创建实现类对象
    3.实现类如果之重写了一部分抽象方法，仍然相当于抽象类
    
*/
public interface MyInter{
    public static final int x = 3;
}

小结：定义和使用接口的流程
1.定义接口MyInter，定义psf属性的成员变量(必须是public)，定义抽象方法
2.创建接口的实现类，继承接口，重写接口所有的抽象方法
3.测试类可以实例化接口的实现类，接口的成员变量可以直接由类名调用(static)，成员变量不能再次修改