JavaSE基础7

复习:

1.变量:
声明(类型 + 变量名) + 初始化
int a = 10;

类型: 基本数据类型 + 引用数据类型

基本数据类型:
	整型:byte/short/int/long
	浮点型:float/double 
	字符型:char  2字节 = 16位
		0 ~ 65535
		'中' '\u0000' 65 97
	布尔类型:boolean

以二进制方式进行存储: 0 和 1
	原码/反码/补码

2.运算符
算数运算符 % ++ –
赋值运算符
比较运算符: boolean类型 返回 true 或 fasle
位运算符: & | ^
逻辑运算符: && & || | ! ^
&& -> 符号两边都是true,结果才是true(一假即假)
位移运算符: >> >>> <<
三目运算符:
表达式[boolean] ? 值1 : 值2

3.逻辑控制语句
顺序
分支 - 条件判断
if(条件)
if - else
if - else if - else

	switch(条件) - case - default
		用来判断是否相等的情况
		能自动转换成 int类型
		String 常量

		break;
		return;
		System.exit(0);

	条件:一定是一个boolean表达式


循环:
	for
	while
	do - while

4.数组
批量定义变量

int[] arr = {1,2,3,4};
int[] arr = new int[]{1,2,3};
int[] arr = new int[5];

数组下标: 从0开始,最大值 length-1

5.方法
public static void main(String[] args){}

方法的使用:
	return
方法参数(临时变量):
	类型 + 变量名	
		基本数据类型: 传值   int a = 10
		引用数据类型: 传递的是引用

6.JVM内存空间
方法区:类相关信息
栈: 局部变量 临时变量
堆: 引用类型的真正数据

类加载: 将字节码文件中的类相关信息读取到JVM方法区中
xx.java -> xx.class

面向对象:
类 和 对象
类: 所有同种对象共同的特征和行为,抽象出来成为类
成员变量
基本数据类型: 0
引用数据类型: null
成员方法
对象:
在主方法中创建对象 -类的实例化
Studnet stu = new Student()

类和对象的关系:
	写法上: 必须现有类 才有对象

	逻辑上: 先有对象,从对象中提取特征

成员变量 和 局部变量的区别
声明位置
初始化
个数
Studnet stu1 = new Student()
stu1.name = 小明
Studnet stu2 = new Student()
stu2.name = 小红

jvm内存中的位置
	局部变量:栈中
	成员变量: 跟对象一起,在堆中

类可以作为成员变量使用:
	类: Studnet
			成员变量:
				int age;
				String name;
				Car car;

		Car

	主方法:
		Studnet stu1 = new Student()
			stu1.car = new Car();

		Car car = new Car();

构造方法/构造器:
目的:给成员变量初始化

this: 表示当前对象
this.name = name

方法的重载:
前提: 必须在同一个类中
方法名一样,方法参数不一样的几个方法
顺序/类型/个数
访问修饰符:
public:所有类可用
protected:父子类关系中
default:同包下
private:在子类类中使用

封装:
1)为了保证成员变量的安全性,把它设置成私有的,也就是添加private修饰词
2)需要给外部提供访问这个成员变量的方法
get():获得
set():设置

JavaBean规范 - 规范实体类

1.命名 驼峰命名法
2.属性必须私有化,给成员变量提供一对get/set方法
3.必须添加无参构造方法

public static void main(String[] args)

Scanner console = new Scanner(System.in);
console.next()
Math.random()
Arrays.toString()

static：静态的

可以修饰：成员变量/成员方法/代码块/内部类

静态成员变量:
    1.属于类的
    2.类名.属性调用 ->  Child.money
    3.只有一个,只分配一次内存
    4.静态变量可以同时被多个实例所共享

    普通成员变量:
        1.属于对象
        2.引用名.属性调用 -> c1.age
        3.根据对象创建内存

静态方法:
  1.静态方法属于类的
  2.类名.方法名调用 ->  Child2.sleep()
  3.在静态方法中,不能直接使用普通的成员变量和成员方法
  4.在成员方法中,可以直接使用静态成员变流量和成员方法


静态代码块
1.属于类的
2.类使用的情况共三种,但是类只加载一次,只执行一次
3.作用:给类的静态成员变量初始化
4.静态代码块可以有多个,但多个没有意义
5.在静态代码块中不能直接使用普通成员变量和成员方法

代码块:

    1.属于对象的,创建多少个对象代码块就多少次
    2.作用:给成员变量初始化(提取构造方法中公共部分)
    3.在构造方法使用前执行

有父子类关系的,代码块的执行顺序是怎么样子的?
静态代码块 代码块 构造方法

xx.java -> xx.class -> 类加载 -> JVM内存中方法区
静态的成员变量和类相关信息一起加载到方法区中
结论:当使用静态成员变量时,对象不一定存在,所以建议静态成员的初始化不要放在构造方法中

类什么时候加载:
第一次使用类的时候,类只加载一次

使用类的情况:
1.创建对象 -> new对象
2.使用静态成员变量
3.使用静态成员方法

方法修饰符 - 4个
static - 静态的
abstract - 抽象的

数组和类结合使用 - 引用类型的数组
1) Student s = new Studnet[3];
s.name = 小明;
2) 空指针异常 nullPointerException
3) 使用步骤:
给数组初始化
Student s = new Studnet[3];
都是null
给数组元素初始化:
s[0] = new Student();
s[0].name = 小明;

继承(extends):
成员方法
方法的重写
成员变量
super -> 父类对象

	Student(String name){
		super.name = name
	}
构造方法
	创建子类对象,先创建父类对象,加载子类之前会先加载父类

方法的重写:
前提:必须在父子类关系中
子类中定义的方法,方法返回值类型/方法名/方法参数都和父类中定义的方法完全一致

抽象类(abstract):
抽象类: 用abstract修饰的类
抽象方法:
public abstract void m1();
所有子类必须重写父类中所有的抽象方法

访问修饰符:
public/protected/(default)/private

封装:
private int a = 10;

给外部提供一对方法: get/set

static: 静态的
成员变量/成员方法/代码块/内部类
static void m1(){
this.m2()
}

void m2(){
	m1();
}

final:最后的

final可以修饰: 类/成员方法/成员变量/局部变量
修饰类: 类不能被继承
修饰成员方法: 方法不能被重写
修饰变量:
	成员变量:变量不能被修改,必须初始化
	局部变量:变量不能被修改,必须初始化

	基本数据类型变量:不能被修改
	引用数据类型变量:
		不能重新赋值,因为会改变地址值
		但是可以改变引用对象的内容

接口: 是一个特殊的抽象类

实际上,接口不是类,是一种引用类型
引用类型: 数组 类 接口

1)接口中可以有什么
(1)所有版本
a.公开的抽象方法
b.公开的静态常量(字段)
(2)JDK1.8
a.静态方法 static
属于接口的,通过接口直接调用

	b.默认方法 default
		通常用来锁接口功能的扩展,可以在实现类中进行选择性的重写
(3)JDK1.9
	a.私有方法 private
		普通私有:
			为了给default方法中的公共代码提取,实现代码复用
		静态私有:
			给static方法中公共代码提取用的

2)使用接口的步骤

(1)接口不能直接new 对象,需要一个实现类来  实现接口
	例如:
		public class A implements InterfaceA()

		将接口中所有抽象方法都进行覆盖重写(实现)
(2)创建实现类对象,并调用方法

常量: final修饰的变量
全部大写,多个单词拼接,使用 _ 进行拼接
EXIT_ON_CLOSE

接口和类关系
接口和接口
类和接口
类和类
接口和类