java面向对象：三大特性：封装

}

}

class Student extends Person{

int stuId;

Student(String name,int age,String address,int stuId){

super(name,age,address);

this.stuId = stuId;

}

void sayHi(){

System.out.println(“我的职业是学生，名为”+name+“，今年”+age+“岁了，家住”+address+“，学号是：”+stuId);

}

}

class Teacher extends Person{

double salary;

Teacher(String name,int age,String address,double salary){

super(name,age,address);

this.salary = salary;

}

void sayHi(){

System.out.println(“我的职业是老师，名为”+name+“，今年”+age+“岁了，家住”+address+“,工资为”+salary);

}

}

class Doctor extends Person{

String level;

Doctor(String name,int age,String address,String level){

super(name,age,address);

this.level = level;

}

void sayHi(){

System.out.println(“我的职业是医生，名为”+name+“，今年”+age+“岁了，家住”+address+“,任职：”+level);

}

}

public class Test {

public static void main(String[] args){

Person[] ps = new Person[4];

ps[0] = new Person(“张发阳”,20,“宝兴兴兴”);

ps[1] = new Student(“张发阳”,25,“宝兴”,1634);

ps[2] = new Doctor(“张发阳”,35,“宝兴兴”,“副院长”);

ps[3] = new Teacher(“张发阳”,45,“宝兴兴兴”,3000);

for(int i =0;i<ps.length;i++){

ps[i].sayHi();

}

}}

———————————————————————————————————

笔记:

1.package:

1)作用:避免类名的冲突

2)包名可以有层次结构

3)类的全称: 包名.类名，同包中的类不能同名

4)建议:包名所有字母都小写

package a;

class Aoo{ } //全称a.Aoo

package b;

class Aoo{ } //全称b.Aoo 不在一个包，所以不报错

class Aoo{ } //错误，一个包里不可以重复类名

import:

1)同包中的类可以直接访问，

不同包中的类不能直接访问，想访问有如下两种方式:

1.1)先import声明类再直接使用类------建议

import oo.day05.Aoo; //声明类

public class Coo {

void show() {

Aoo o = new Aoo();

o.a = 1;

}}

1.2)类的全称------------------------太繁琐、不建议

void show() {

oo.day05.Aoo o = new oo.day05.Aoo();

oo.day05.Aoo.a = 1;

2.访问控制修饰符:

1)public:公开的，任何类

2)private:私有的，本类

3)protected:受保护的，本类、派生类、同包类

4)默认的:什么也不写，本类、同包类

说明:

1)类的访问修饰符只能是public或默认的

2)类中成员的访问修饰符如上四种都可以

修饰符 本类 同一个包中的类 子类 其他类

public 可以访问 可以访问 可以访问 可以访问

private 可以访问 不能访问 不能访问 不能访问

protected 可以访问 可以访问 可以访问 不能访问

默认 可以访问 可以访问 可以访问 不能访问

例：

public int a; //任何类

protected int b; //本类、派生类、同包类

int c; //本类、同包类

private int d; //本类

void show() {

a = 1;

b = 2;

c = 3;

d = 4;

}}

//演示private

class Boo{

void show() {

Aoo o = new Aoo();

o.a = 1;

o.b = 2;

o.c = 3;

//o.d = 4;

}}

3.final:最终的、不可改变的----应用率低

1)修饰变量:变量不能被改变

//演示final修饰方法

//演示final修饰变量

class Eoo{

final int a = 5;

final int b;

Eoo(){

b = 6;

}

void show() {

final int c;

//a = 55; //编译错误，final的变量不能被改变

}}

2)修饰方法:方法不能被重写

class Foo{

final void show() {}

void test() {}

}

class Goo extends Foo{

//void show() {} //编译错误，final修饰的方法不能被重写

void test() {}

}

3)修饰类:类不能被继承

//演示final修饰类

final class Hoo{}

//class Ioo extends Hoo{} //编译错误，final修饰的类不能被继承

class Joo{}

final class Koo extends Joo{}

4.static:静态的

1)静态变量:

1.1)由static修饰

1.2)属于类的，存储在方法区中，只有一份

1.3)常常通过类名点来访问

1.4)何时用:所有对象所共享的数据(图片、音频、视频等)

2)静态方法:

2.1)由static修饰

2.2)属于类的，存储在方法区中，只有一份

2.3)常常通过类名点来访问

2.4)静态方法没有隐式this传递，

静态方法中不能直接访问实例成员

2.5)何时用:方法的操作仅与参数相关而与对象无关

3)静态块:

3.1)属于类的，在类被加载期间自动执行，

类只被加载一次，所以静态块只执行一次

3.2)何时用:用于加载/初始化静态资源(图片、音频、视频等)

//static的演示

public static void main(String[] args) {

Loo o1 = new Loo();

o1.show();

Loo o2 = new Loo();

o2.show();

System.out.println(Loo.b); //2，建议类名点来访问

Moo.test(); //类名点来访问

Noo o4 = new Noo();

Noo o5 = new Noo();

}}

//演示静态块

class Noo{

static {

System.out.println(“静态块”);

}

Noo(){

System.out.println(“构造方法”);

}}

//演示静态方法

class Moo{

int a;

static int b;

void show() { //有this

System.out.println(this.a);

System.out.println(Moo.b);

}

static void test() { //没有this

//静态方法没有隐式this传递

//没有this意味着没有对象

//而实例变量a必须通过对象点来访问

//结论:静态方法中不能直接访问实例成员

//System.out.println(a); //编译错误

System.out.println(Moo.b);

}}

//演示静态变量

class Loo{

int a;

static int b;

Loo(){

a++;

b++;

}

void show() {

System.out.println(“a=”+a+“,b=”+b);

}}

内存管理: （背）

1)堆:new出来的对象(包括实例变量)

2)栈:局部变量(包括方法的参数)

3)方法区:.class字节码文件(包括方法、静态变量)

例：成员变量:

1)实例变量:没有static修饰，属于对象的，存储在堆中，

有几个对象就有几份

通过对象名点来访问

2)静态变量:由static修饰，属于类的，存储在方法区中，

只有一份

通过类名点来访问

—————————————————————————————

笔记:

1.static final常量:

1)必须声明同时初始化

2)类名点来访问、不能被改变

3)建议:常量名所有字母都大写，多个单词之前用_分隔

4)编译器在编译时将常量直接替换为具体的值，效率高

5)何时用:数据永远不变，并且经常使用

2.抽象方法:

1)由abstract修饰

2)只有方法的定义，没有具体的实现(连{}都没有)

3.抽象类:

1)由abstract修饰

2)包含抽象方法的类必须是抽象类

不包含抽象方法的类也可以声明为抽象类------我乐意

3)抽象类不能被实例化 ，但数组可以

4)抽象类是需要被继承的，派生类:

4.1)重写抽象类中的所有抽象方法-----建议

4.2)也声明为抽象类-----------------一般不这样做

5)抽象类的意义:

5.1)封装共有的属性和行为--------------代码复用

5.2)为所有派生类提供统一的类型--------向上造型

5.3)可以包含抽象方法，为所有派生类提供统一的入口，

派生类的具体实现不同，但入口是一致的

设计规则:

1)将派生类共有的属性和行为，抽到超类中--------抽共性

2)派生类的行为都一样，设计为普通方法

派生类的行为都不一样，设计为抽象方法

————————————————————————————————

常见面试题：

问： 内部类有独立.class吗?

答： 有

例：Mama$(发音：多嘞儿)baby.class //Mama外部类，baby内部类

1.成员内部类：应用率不高

1）类中套类，外面的称为Outer外部类，里面的成为Inner内部类

Class Aoo{ //外部类

Class Boo{//内部类

｝｝

使用方法：

public static void main(String[] args) {

Demo14 a = new Demo14();

Foo f = a.new Foo();

f.Doo();

}

2)内部类通常只服务于外部类，对外不具备可见性

3)内部类对象通常是在外部类中创建的

4)内部类中可以直接访问外部类的成员(包括私有的)

内部类中有个隐式的引用指向了创建它的外部类对象

eg: 外部类名.this

2.匿名内部类:

1)若想创建一个类(派生类)的对象，并且对象只创建一个，

此时该类不必命名，称为匿名内部类

2)在jdk1.8以前，匿名内部类中若想访问外面的变量，

该变量必须是final的

功能实现过程:

1.先写行为/方法:

1)若为某个对象所特有的行为，就将方法设计在对应的类中

2)若为所有对象所共有的行为，就将方法设计在超类中

2.页面/窗口调用:

1)若为定时触发的，则在定时器中调用

2)若为事件触发的，则在侦听器中调用

程序的运行结果与你所预期的结果不同:

1)打桩: System.out.println(数据);

2)Debug调试:

————————————————————————————————

笔记:

1.接口:

1)是一种数据类型(引用类型)

2)由interface定义

3)只能包含常量和抽象方法

4)接口不能被实例化

5)接口是需要被实现/继承的，实现类/派生类:

必须重写所有抽象方法

6)一个类可以实现多个接口，用逗号分隔

若又继承又实现时，应先继承后实现

7)接口继承接口(可以继承多个接口)

设计规则:

1)将所有派生类所共有的属性和行为，抽到超类中-----抽共性

2)派生类的行为都一样，设计为普通方法

派生类的行为都不一样，设计为抽象方法

3)将部分派生类所共有的行为，抽到接口中

符合既是也是原则时，需使用接口

接口是对继承单根性的扩展----------实现多继承

————————————————————————————

笔记:

1.多态:

1)多态的意义: //抽象方法一定是多态

1.1)同一类型的引用指向不同的对象时，有不同的实现

----行为的多态:cut()、run()、step()…

1.2)同一个对象被造型为不同的类型时，有不同的功能

----对象的多态:我、你、水…

2)向上造型/自动类型转换:

2.1)超类型的引用指向派生类的对象

2.2)能造型成为的类型有: 超类+所实现的接口

2.3)能点出来什么，看引用的类型

3)强制类型转换，成功的条件只有如下两种:

3.1)引用所指向的对象，就是该类型

3.2)引用所指向的对象，实现了该接口或继承的该类

4)强转时若不符合如上条件，则发生ClassCastException类型转换异常，

建议在强转之前先通过instanceof(实例)来判断引用的对象是否是该类型

基本类型之间强制类型转换，

---------一定正确，但有可能溢出或丢失精度

引用类型之间强制类型转换，

---------有可能会失败报错

超类大，派生类小

自动:小类型到大类型

强制:大类型到小类型

—————————————————————————————————

正课:

1.内存管理:由JVM来管理的------了解

1)堆:

1.1)存储new出来的对象(包括实例变量)

1.2)垃圾:没有任何引用指向的对象

垃圾回收器(GC)不定时到内存中清扫垃圾，

回收过程是透明的(看不到的)，

不一定一发现垃圾就立刻回收，

调用System.gc()可以建议JVM尽快调度GC来回收

1.3)内存泄漏:不再使用的对象还没有被及时的回收

建议:对象不再使用时应及时将引用设置为null

1.4)实例变量的生命周期:

创建对象时存储在堆中，对象被回收时一并被回收

2)栈:

2.1)存储正在调用的方法中的局部变量(包括方法参数)

2.2)调用方法时会为该方法在栈中分配一块对应的栈帧，

栈帧中存储局部变量(包括方法参数)

当方法调用结束时，栈帧被清除，局部变量一并失效

2.3)局部变量的生命周期:

调用方法时存储在栈中，方法结束时与栈帧一并被清除

3)方法区:

3.1)存储.class字节码文件(包括方法、静态变量)

3.2)方法只有一份，通过this来区分具体的调用对象

+++++++++++++++++++++++++++++++++++++

总结：

面向对象三大特征:

1.封装:

1)类:封装的是对象的属性和行为

2)方法:封装一段特定的是业务逻辑功能实现

3)访问控制修饰符:封装的是具体的访问权限

2.继承:

1)作用:代码复用

2)超类:所有派生类所共有的属性和行为

接口:部分派生类所共有的行为

派生类:派生类所特有的属性和行为

3)单一继承、多接口实现，传递性

3.多态:

1)意义:

1.1)行为的多态(所有抽象方法都是多态的)

1.2)对象的多态(所有对象都是多态的)

2)向上造型、强制类型转换、instanceof判断

3)多态的表现形式:

3.1)重写:根据对象的不同来表现多态

3.2)重载:根据参数的不同来表现多态

设计游戏思路（面向对象课程安排）：

Shoot射击游戏第一天:

1.创建了6个对象类，创建World类测试

（理论:

1.什么是类？什么是对象？

2.如何创建类？如何创建对象？如何访问成员？

项目:

3.创建了6个对象类，并创建World类测试）

Shoot射击游戏第二天:

1.给6个对象类添加构造方法，并测试

（理论:

1.方法的重载

2.构造方法

3.this

5.null和NullPointerException

6.引用类型之间画等号

项目:

4.给6个对象类添加构造方法，并测试）

Shoot射击游戏第三天:

1.设计小敌机数组、大敌机数组、小蜜蜂数组、子弹数组，并测试

2.设计超类FlyingObject，6个对象类继承

3.给FlyingObject类设计两个构造方法，6个对象类分别调用

（ 理论:

1.引用类型数组

3.继承

5.super

项目:

2.设计小敌机数组、大敌机数组、小蜜蜂数组、子弹数组，并测试

4.设计FlyingObject超类，6个对象类继承

6.给FlyingObject超类设计两个构造方法，6个对象类分别调用）

Shoot射击游戏第四天:

1.将小敌机数组、大敌机数组、小蜜蜂数组合为FlyingObject数组，并测试

2.在6个对象中重写step()

3.画窗口

（理论:

1.向上造型

3.方法的重写

4.重写与重载的区别

项目:

2.将小敌机数组、大敌机数组、小蜜蜂数组合为FlyingObject数组，并测试

5.在6个派生类中重写超类的step()方法

6.画窗口）

Shoot射击游戏第五天:

1.给类中成员添加访问控制修饰符

2.给6个对象设计图片属性

（理论:

1.package和import

2.访问控制修饰符

4.final

5.static

项目:

3.给类中成员添加访问控制修饰符

6.给6个对象设计图片属性）

Shoot射击游戏第六天:

1.设计窗口的宽和高为常量，适当地方做修改

2.画对象:

1)想画对象得获取对象的图片，每个对象都能获取图片，

意味着获取图片行为为共有行为，设计为超类FlyingObject中，

每个对象获取图片的行为都是不一样的，所以设计为抽象方法

----在FlyingObject中设计抽象方法getImage()来获取对象的图片

2)对象在获取图片时需要考虑对象在不同状态下获取不同的图片，

所以要给对象设计状态，每个对象都有状态，

所以将状态设计在超类中，而状态一般都是常量

----在FlyingObject中设计三个常量，state变量表示当前状态

在获取图片时需要先对对象的状态进行判断，

每个对象都得判断，所以将判断状态行为设计在超类中，

每个对象判断状态的方式都是一样的，所以设计为普通方法

----在FlyingObject中设计isLife()、isDead()、isRemove()来判断对象的状态

3)----重写FlyingObject中的抽象方法getImage():

3.1)天空Sky，直接返回image即可

3.2)子弹Bullet:

3.2.1)若活着的，直接返回image即可

3.2.2)若死了的，则删除

3.3)英雄机Hero:

3.3.3)若活着的，返回images[0]和images[1]的来回切换

3.4)小敌机Airplane:

3.4.1)若活着的，直接返回images[0]

3.4.1)若死了的，返回images[1]到images[4]的轮转，4后则删除

3.5)大敌机Airplane:

3.5.1)若活着的，直接返回images[0]

3.5.1)若死了的，返回images[1]到images[4]的轮转，4后则删除

3.6)小蜜蜂Airplane:

3.6.1)若活着的，直接返回images[0]

3.6.1)若死了的，返回images[1]到images[4]的轮转，4后则删除

4)图片有了则可以开画了，每个对象都能画，

意味着画为共有的行为，所以设计在超类中，

每个对象画的方式都是一样的，所以设计为普通方法

----在FlyingObject中设计paintObject()实现画对象
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

手绘了下图所示的kafka知识大纲流程图（xmind文件不能上传，导出图片展现），但都可提供源文件给每位爱学习的朋友

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
普通方法

----在FlyingObject中设计paintObject()实现画对象
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-VQUZ2nXP-1712634050097)]

[外链图片转存中…(img-hi3IbzDq-1712634050098)]

[外链图片转存中…(img-nI9r0FQJ-1712634050098)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

手绘了下图所示的kafka知识大纲流程图（xmind文件不能上传，导出图片展现），但都可提供源文件给每位爱学习的朋友

[外链图片转存中…(img-1WbCH2Y1-1712634050098)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！