笔记03

飞机大战分析:
对象提取类:小敌机/大敌机/自己的飞机/子弹/小蜜蜂

小敌机类:
  成员变量:
  	int x,int y,图片,int width
  	int height, 
  成员方法:
  	move()
大敌机类:
	成员变量:
	int x,int y, 图片,int width
  	int height ,  int life
  	成员方法:
  	move()
自己的飞机类:
	int x,int y, 图片,int width
  	int height , int life,int score,子弹
  	成员方法:
  	move()
子弹类:
	int x,int y, 图片,int width
  	int height
  	成员方法:
  	move()
小蜜蜂类:
	int x,int y, 图片,int width
  	int height
  	成员方法:
  	move()

把所有类中相同的成员变量和成员方法 -> 提取出来 -> 形成一个类 -> 父类

升级版:
子类 extends 父类

父类(基类):
  成员变量:
    int x,int y, 图片,int width
  	int height
  成员方法:
  	move()
子类(衍生类/扩展类):
  小敌机类:
  大敌机类:
  	int life
  自己的飞机类:
  	int life,子弹,int score
  子弹类:
  小蜜蜂类:

1.继承(extends)
1.结构:
子类(衍生类/扩展类) extends 父类/基类
2.继承的特征:
1)子类继承父类,会继承父类中所有的成员变量和成员方法
)所有的类,都有唯一的父类
如果没有写父类,那么就会默认继承Object
)子类可以拥有自己独有的成员变量和成员方法
并且,子类的功能一定会比父类的更强大
4)一个类只能继承一个父类,但是一个父类可以有很多个子类

特殊情况:
1.创建子类对象之前,会先创建父类对象
加载子类之前会先加载父类
2.构造方法:
调用子类构造方法之前,一定会调用父类的构造方法,默认调用父类的无参构造方法
3.子类中可以引用父类对象
4.子类和父类中有相同的成员变量时
例如: name
那么会先去运行子类中成员变量,如果没有才会去找父类中的成员变量

	建议:子类和父类中不要有相同的成员变量
5.通过子类对象调用方法时
	会先去找子类中有没有这个方法,如果有就实现子类中的内容
	如果没有,就会往上去找父类中的方法

2.super关键词:
1)调用子类构造方法之前,一定会调用父类的构造方法,默认调用父类的无参构造方法
使用super关键词调用
2)父类中的构造方法只能调用,不能继承,默认添加super()
3)如果父类中没有无参构造方法,就需要手动调用父类中的有参构造方法
super(参数)
4)super(参数),只能放在构造方法的第一行

3.方法的重写
1)重写的前提:
必须存在父子类关系
2)语法结构:
子类中定义的方法的方法名+方法参数+返回值类型都必须和父类中完全一致

方法的重写(Override)和方法的重载(Overload)的区别:
	方法的重写的前提:
		必须在父子类关系中
	方法的重载的前提:
		必须在同一个类中
		参数不一样:
			个数
			顺序
			类型

this和super的区别:

复习:
继承
1.子类继承父类,继承父类中所有(private)成员变量和成员方法
2.所有类都默认继承父类Object
3.构造方法只能调用,不能被继承
4.spuer()/this() - 父类对象/当前对象

重写:
前提:必须要有父子类关系
子类中的方法名/方法参数/返回值类型必须一致
重载:
前提:在同一个类中
方法参数不一致(类型/顺序/个数)
跟返回值无关

访问修饰符:
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 - 抽象的

4.抽象(abstract)
abstract可以修饰: 修饰类/方法

1)抽象方法:
a.出现的前提:
例如:move()
所有的子类中的move()都有不同的实现,那也就是说明父类中的move()方法体没有意义
没有意义的东西不需要 -> 删除 -> 抽象方法 -> 加abstract
b.子类必须重写父类中的抽象方法
如果不重写,就要把自己变成抽象类
c.抽象方法的特点
1.没有方法体的方法叫抽象方法
2.抽象方法一定要存在于抽象类中

2)抽象类
a.abstract修饰的类叫抽象类
b.抽象类不能new对象,也就是不能创建类的实例化
c.抽象类也有构造方法,就是为了给子类使用的

3)abstract不能修饰成员变量,因为成员变量是有具体的类型

判断:
有抽象方法的类就是抽象类 √
抽象类就是有抽象方法的类 ×
没有抽象方法的也是抽象类 √

5.访问修饰符/权限控制符
public:公开的,公共的
protected:受保护的
default:默认的,(default)是不写的,没有的这个词
private:私有的

访问控制符可以修饰:修饰类/修饰[静态]成员变量/修饰[静态]成员方法/代码块/构造方法

自己类中: 所有的访问修饰符都可用
同包(没有任何关系的类): public default protected
不同包下(有父子关系的类): public protected
所有类(不同包下没有任何关系的类):public

访问权限的范围:
最大的是public,最小的是private

使用情况:
public:想让所有的类都可见时
protected:在父子类关系中可用
default:不常用,练习时使用
private:普通类中都可用
get/set

封装

继承 封装 多态 抽象