Java面向对象和封装-基础知识笔记（黑马视频基础部分）

JRE和JDK

• JRE（Java Runtime Environment）:Java程序运行环境，包含JVM和运行时所需要的核心类库（环境信息）。
• JDK（Java Development Kit）:Java程序开发工具包，包含JRE和开发人员使用工具。
• 运行一个已有程序，安装JRE
• 开发一个全新程序，安装JDK
  

方法

方法的三种调用方式：

1. 单独调用：方法名（参数）
2. 打印调用：System.out.pringln(方法名称(参数));
3. 赋值调用：数据类型 变量名称=方法名称(参数);
   返回值类型为void的方法，不能进行打印调用和赋值调用，只能进行单独调用

方法的重载（Overload）： 方法名称相同，参数列表不同
参数列表不同，指：①参数个数不同；②参数类型不同；③参数的多类型顺序不同。与参数名称无关，与方法返回值类型无关。

Java内存划分

Java内存划分分为5部分：

1. 栈（Stack）：存放的都是方法中的局部变量（方法的参数，或方法{ }内部的变量）。
   方法的运行一定要在栈当中
   作用域：一旦超出作用域，立刻从栈内存中消失。
2. 堆（Heap）:凡是new出来的东西，都在堆中
   堆内存中的东西都有一个地址值：16进制
   堆内存中的数据，都有默认值。规则：整数默认0，浮点数默认0.0，字符默认‘\u0000’,布尔值默认false，引用类型默认null
3. 方法区（Method area）：存储.class相关信息，包含方法的信息
4. 本地方法栈（Native Method Stack）：与操作系统相关
5. 寄存器（pc Register）：与cpu相关

一个数组的内存图：

public class ArrayOne{
	public static void main(String[] args){
		int[] array=new int[3];  //动态初始化
		System.out.println(array);   //地址值
		System.out.println(array[0]);   //0
		System.out.println(array[1]);   //0
		System.out.println(array[2]);   //0
		//改变数组元素内容
		array[1]=10;
		array[2]=20;
		System.out.println(array);   //地址值
		System.out.println(array[0]);   //0
		System.out.println(array[1]);   //10
		System.out.println(array[2]);   //20
	}
}

栈中存放的为数组的地址值

一个对象的内存图

public class Phone{
	String brand;  //品牌
	double price; //价格
	String color;  //颜色
	public void call(String who){
		System.out.println("给"+who+"打电话"); }
	public void sendMessage(String who){
		System.out.println("群发短信"); }
}
public class Demo01PhoneOne {
    public static void main(String[] args) {
        //根据Phone类创建对象
        Phone one=new Phone();
        one.brand="苹果";
        System.out.println(one.brand);
        one.call("乔布斯");
        one.sendMessage();
    }
}

使用对象类型作为方法的参数

public class PhoneParam{
	public static void main(String[] args){
		Phone one=new Phone();
		one.brand="苹果";
		one.price=8388.0;
		one.color="金";
		method(one);   //传递进去的参数其实是地址值
	}
	public static void method(Phone param){
		System.out.println(param.brand);
		System.out.println(param.price);
		System.out.println(param.color);
	}
}

当一个对象作为参数，传递到方法中时，实际上传进去的是对象的地址值。
当使用一个对象类型作为方法的返回值时，返回值其实是对象的地址值。

局部变量Vs成员变量

1. 定义位置不同：
   局部变量——方法内部
   成员变量——方法外部，直接写在类中
2. 作用范围不同
   局部变量——只能在方法中使用，出方法不再使用
   成员变量——整个类都可以通用
3. 默认值不同
   局部变量——没有默认值，需手动赋值
   成员变量——若没有赋值，有默认值，规则与数组相同
4. 内存位置不同
   局部变量——位于栈内存
   成员变量——位于堆内存
5. 生命周期不同
   局部变量——随方法进栈而诞生，随方法出栈而消失
   成员变量——随对象创建而诞生，随对象被垃圾回收而消失

private关键字

成员变量使用private关键字进行修饰，本类中仍可随时访问，超出本类范围不可直接访问。
间接访问：定义一对Getter/Setter方法

public class Person{
	private int age;
	public void setAge(int num){
		age=num;
	}
	public int getAge(){
		return age;
	}
}

set方法，有参数，无返回值，参数与set的成员变量保持一致
get方法，无参数，有返回值，返回值类型与成员变量保持一致
命名规则：setXxx/getXxx
使用private修饰的作用：外部不可直接访问，间接访问可通过条件设置，阻止不合理的数据，提高代码的安全性。
对于基本类型中的boolean类型，Getter方法一定要写成isXxx的形式，而setXxx规则不变。

	public class Student {
    private String name;   //姓名
    private boolean male;  //是否是男性
    public void setName(String str){
        name=str;
    }
    public String getName(){
        return name;
    }
    public void setMale(boolean b){
        male=b;
    }
    public boolean isMale(){
        return male;
    }
}

this关键字

当方法的局部变量和类的成员变量重名时，根据就近原则，会优先选择局部变量

如果需访问本类中的成员变量，需使用格式：this.成员变量
this一定是写在方法中的，通过谁调用的方法，谁就是this

//本例中，this写在sayHello()方法中，person通过调用sayHello()方法，因此this即为person的name
//this和person中保存的地址值相同

public class Person {
    String name;  //我自己的名字
    //参数name是对方的名字
    //成员变量name是自己的名字
    public void sayHello(String name){
        System.out.println(name+"，你好，我是"+this.name);
        System.out.println(this);
    }
}
public class Demo01Person {
    public static void main(String[] args) {
        Person person = new Person();
        person.name="王健林";
        person.sayHello("王思聪");
        System.out.println(person);
    }
}

构造方法

构造方法是专门用来创建对象的方法，当我们通过关键字new创建对象时，其实就是在调用构造方法。
格式：public 类名称（参数类型 参数名称）{ 方法体 }
用途：创建对象

注意：

1. 构造方法名称必须与类名称完全相同，大小写也要一样
2. 构造方法没有返回值类型。
3. 构造方法不能return一个具体返回值
4. 如果没有编写任何构造方法，那么编译器会默认生成一个构造方法，没有参数，方法体什么事情都不做
   public Student(){ }
5. 一旦编写了至少一个构造方法，那么编译器不再自动生成
6. 构造方法也可以进行重载（方法名称相同，参数列表不同）

public class Student {
    //成员变量
    private String name;
    private int age;
    
    //无参构造方法
    public Student(){
        System.out.println("无参构造方法执行");
    }
    
    //全参构造方法
    //可以通过构造方法直接进行参数传递，不用使用Setter方法进行传参
    public Student(String name, int age){  
        System.out.println("全参构造方法执行");
        this.name=name;
        this.age=age;
    }
    
    //Getter Setter
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
}

public class Demo02Student {
    public static void main(String[] args) {
        Student stu1=new Student();     //无参构造
        Student stu2=new Student("赵丽颖",20);    //全参构造
        System.out.println("姓名："+stu2.getName()+"，年龄："+stu2.getAge());
        
        //如果需要改变对象中成员变量的数据内容，仍然需要通过setXxx方法
        stu2.setAge(21);
        System.out.println("姓名："+stu2.getName()+"，年龄："+stu2.getAge());
    }
}

输出结果：

Java Bean 标准类

标准的类也叫作Java Bean

一个标准类通常需要满足下列四个组成部分:

1. 所有成员变量都要使用private关键字修饰
2. 为每一个成员变量编写一对Getter/Setter方法
3. 编写一个无参数的构造方法
4. 编写一个全参数的构造方法