标签：Java 构造方法 -- 面向对象 对象 超类 派生类 方法 第一阶段
第一天
一、什么是类？什么是对象？
1.现实生活中是由很多很多对象组成的，基于对象抽出类
2.对象：软件中真实存在的单个个体/东西
类:类别/类型,代表一类个体
3.类是对象的模子,对象是类的具体的实例
4.类可以包含:
对象的属性/特征--------成员变量
对象的行为/动作--------方法
5.一个类可以创建多个对象
二、创建类,创建对象,访问成员
三、方法重载（overload）-----更加方便用户访问
发生在同一类中，方法名相同，参数列表不同
四、项目：潜水艇
潜艇游戏需求:
1.所参与的角色:
窗口:宽(?),高(479)
1)战舰Battleship
属性:宽(66),高(26),x坐标(270),y坐标(124),移动速度(20),命数(5)
行为:移动move()
2)侦察潜艇ObserveSubmarine
属性:宽(63),高(19),x坐标(-width),y坐标(150到(窗口高-潜艇高)之内的随机数),移动速度(1~3)
行为:移动move()
3)鱼雷潜艇TorpedoSubmarine
属性:宽(64),高(20),x坐标(-width),y坐标(150到(窗口高-潜艇高)之内的随机数),移动速度(1~3)
行为:移动move()
4)水雷潜艇MineSubmarine
属性:宽(63),高(19),x坐标(-width),y坐标(150到(窗口高-潜艇高)之内的随机数),移动速度(1~3)
行为:移动move()
5)水雷Mine
属性:宽(11),高(11),x坐标(写活),y坐标(写活),移动速度(1)
行为:移动move()
6)深水炸弹Bomb
属性:宽(9),高(12),x坐标(写活),y坐标(写活),移动速度(2)
行为:
2.角色间的关系：
1_1)战舰发射深水炸弹;
1_2)深水炸弹可以打潜艇(侦察潜艇、鱼雷潜艇、水雷潜艇),若打中:
① 潜艇消失,深水炸弹消失;
② 得东西:
打掉侦察潜艇,玩家得10分;
打掉鱼雷潜艇,玩家得40分;
打掉水雷潜艇,战舰得1条命.
2_1)水雷潜艇可以发射水雷;
2_2)水雷可以击打战舰,若打中:
① 水雷消失;
② 战舰减一条命(命数为0时游戏结束).
第二天
一、构造方法(构造函数、构造器、构建器)-----------复用给成员变量赋初值代码（作用）
--方法名与类名相同，且没有返回值类型（void都没有）
--在创建(new)对象时自动被调用
--若不写构造方法,编译器默认提供一个无参构造方法,若写构造方法,编译器不会自动生成构造方法
--构造方法可以重载
二、this:指代当前对象,哪个对象调用方法它指的就是哪个对象
1. 只能用在方法中,方法中访问成员变量之前默认有个this.
2.this的用法:
1)this.成员变量名---------------访问成员变量
成员变量与局部变量同名时，若想访问成员变量则this不能省略
2)this.方法名----------调用方法(了解)
3)this()-------------------调用构造方法(了解)
三、null和NullPointerException
null表示空,没有指向任何对象,若引用的值为null,则该引用不能进行任何点操作了,否则会发生NullPointerException空指针异常
四、引用类型数组(以潜艇项目为例)
Bomb[] bs = new Bomb[3];
bs[0] = new Bomb(100,200); //1)给元素赋值需要去new个对象
bs[1] = new Bomb(200,300);
bs[2] = new Bomb(220,330);
//2)若想访问对象的数据，需要通过数组元素去打点
bs[0].x = 111; //给第1个炸弹的x修改为111
System.out.println(bs[1].width); //输出第2个炸弹的宽
bs[2].move(); //第3个炸弹移动五、补充
1.内存管理:由JVM管理
1)堆内存:new的对象(还有实例变量)
2)栈内存: 局部变量(包括方法的参数)
第三天
一. 引用类型数组：
二. 继承：
- 作用：代码复用
- 通过extends来实现继承
- 超类/父类：共有的属性和行为
派生类/子类：特有的属性和行为
- 派生类既能访问自己的，也能访问超类的，但超类不能访问派生类的
- 一个超类可以有多个派生类
一个派生类只能有一个超类-----------单一继承
- 具有传递性
- java规定：构造派生类之前必须先构造超类
- 派生类的构造方法中若没有调用超类的构造方法，则默认super()调用超类的无参构造方法
- 派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供
super()调用超类构造方法，必须位于派生类构造方法的第一行
三. super：指代当前对象的超类对象
super的用法：
- super.成员变量名----------------------访问超类的成员变量(了解)
- super.方法名()---------------------------调用超类的方法----------明天讲
- super()-------------------------------------调用超类的构造方法
四. 向上造型：---------------------代码复用
- 超类型的引用指向了派生类的对象
- 能点出来什么，看引用的类型-----------这是规定，记住就OK了
补充：
1. 继承意味着代码虽然我没有写，但也属于我，只是没有写在一起而已
2. 泛化：将共有的抽出来的过程，泛化是设计层面的概念，从代码实现层面来说咱们就是继承，泛化就是继承
3. 继承要符合is a(是一个)的关系
第四天
一、方法的重写(override/overriding):重新写、覆盖
1.发生在父子类中，方法名相同，参数列表相同
2.重写方法被调用时，看对象的类型
二、重写与重载的区别(面试重点):
1.重写(override)-------父子类中,方法名相同,参数列表相同
多态中,重写的方法看对象
一般用于在派生类中修改超类的方法
2.重载(overload)------同类中,方法名相同,参数列表不同
是完全不同的方法，只是方法名相同而已
三、package和import
- package：声明包
- 作用：避免类的命名冲突
- 同包中的类不能同名，不同包中的类可以同名
- 类的全称：包名.类名，包名常常有层次结构
- 建议：包名所有字母都小写> 说明：package声明包必须位于第一行
- import：导入类
- 同包中的类可以直接访问，不同包的类不能直接访问，若想访问：
- 先import导入类，再访问类----------建议
- 类的全称-----------------------------------太繁琐，不建议> 说明：import导入类必须位于声明包的下一行
四、访问控制修饰符
封装的意义：隐藏一些东西，暴露一些东西，来保护数据的安全
public:公开的,所有类
protected:受保护的 当前类,派生类,同包类
默认的:本类,同包类
private:私有的 本类
1. 类的访问权限只能是public或默认的
2. 类中成员的访问权限如上四种都可以
五、static:静态的
静态变量：
- 由static修饰
- 属于类，存储在方法区中，只有一份
- 常常通过类名点来访问
- 何时用：所有对象所共享的数据(图片、音频、视频等)
- 静态方法：
- 由static修饰
- 属于类，存储在方法区中，只有一份
- 常常通过类名点来访问
- 静态方法没有隐式this传递，所以不能直接访问实例成员
- 何时用：方法的操作与对象无关
- 静态块：
- 由static修饰
- 属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块也只执行一次
- 何时用：初始化/加载静态资源(图片、音频、视频等)
补充：
1. 成员变量分两种：
- 实例变量：没有static修饰，属于对象的，存储在堆中，
有几个对象就有几份，通过引用打点来访问
- 静态变量：有static修饰，属于类的，存储在方法区中，
只有一份，通过类名打点来访问
2. 内存管理：由JVM来管理的
- 堆：new出来的对象(包括实例变量)
- 栈：局部变量(包括方法的参数)
- 方法区：.class字节码文件(包括静态变量、所有方法)3. 在构造方法中给实例变量做初始化
在静态块中给静态变量做初始化
4.两同两小一大
1)两同:方法名相同,参数列表相同
2)两小:
派生类方法的返回值类型必须小于或等于超类方法的
----是void或基本数据类型时,必须相等
----引用类型时,小于或等于
派生类方法抛出的异常必须小于或等于超类方法的
3)一大:
派生类方法的访问权限必须大于或等于超类方法的
第五天
一、final
1.修饰变量：变量不能被改变
2.修饰方法：方法不能被重写
3.修饰类：类不能被继承
二、static final常量
1.必须声明同时初始化
2.通过类名点来访问，不能被改变
3.建议：常量名所有字母都大写，多个单词用_分隔
4.编译器在编译时会将常量直接替换为具体的值,效率高
5.何时用:数据永远不变,并且经常使用
三、抽象方法:
1.由abstract修饰
2.只有方法的定义,没有具体的实现(连{}都没有)
四、抽象类:
1.由abstract修饰
2.包含抽象方法的类必须是抽象类
3.抽象类不能被实例化(new对象)
4.抽象类是需要被继承的,派生类:
1)重写所有抽象方法-------变不完整为完整
2)也声明为抽象类----------一般不这么做
五.抽象类的意义:
1)封装共有的属性和行为----代码复用
2)为所有派生类提供统一的类型------向上造型----代码复用
3)可以包含抽象方法，为所有派生类提供统一的入口(能点出来)
----派生类的行为不同，但入口是一致的，同时相当于定义了一个标准
补充：
设计规则：
---符合既是也是原则时,应使用接口
将所有派生类所共有的属性和行为，抽到超类中-------------抽共性
派生类的行为都一样，则设计为普通方法
派生类的行为不一样，则设计为抽象方法
将部分派生类共有的属性和行为，抽到接口中
接口是对继承的单根性的扩展-----------实现多继承
抽象方法/抽象类的疑问:
抽象方法的存在意义是什么？
保证当发生向上造型时，通过超类型的引用能点出来那个方法既然意义只在于能点出来，那为什么不设计为普通方法？
若设计为普通方法，则派生类可以重写也可以不重写，而设计为抽象方法，可以强制派生类必须重写------做了个标准，强制必须重写
第六天
一、成员内部类：应用率低，了解
class Aoo{ //外部类
class Boo{ //内部类
}
}--类中套类，外面的称为外部类，里面的称为内部类
--内部类通常只服务于外部类，对外不具备可见性
--内部类对象只能在外部类创建
--内部类可以直接访问外部类的成员（包括私有的），在内部类中有个隐式的引用指向了创建它的外部类对象---外部类名.this
二、匿名内部类：应用率高
--若想创建一个类(派生类)的对象,并且对象只创建一个,此时该类不必命名,称为匿名内部类
--匿名内部类中不能修改外面变量的值,因为在此处默认变量为final的
public class AnonInnerClassDemo{
public static void main(String[] args){
//1)创建了Aoo的一个派生类,但没有名字
//2)为该派生类创建了一个对象,名为o1
//3)大括号中的为派生类的类体
Aoo o1 = new Aoo(){
};
//由于大括号为派生类的类体,所以抽象方法要重写
Boo o2 = new Boo{
void show(){
System.out.println( "showshow" );
}
};
o2.show();
}
}
abstract class Boo{
abstract void show();
}
abstract class Aoo{
}补充：
1.隐式对象:
--this:当前对象
--super:当前对象的超类对象
--外部类名.this:当前对象的外部类对象
2.必须记住的,API中会用的:
--外部类名.this-------------指代当前对象的外部类对象
--匿名内部类不能修改外面变量的值,因为在此处默认变量为final的
3.面试题:
--问:内部类独立生成.class字节码文件吗?
--答:是
4.做功能的套路:
1)先写行为/方法:
--若为某对象所特有的行为,就将方法设计在特定的类中
--若为所有对象所共有的行为,就将方法设计在超类中
2)窗口调用:
--若为定时发生的,就在定时器中调用
--若为事件触发的,就在侦听器中调用
5.调错方式
--打桩:System.out.println(数据);
第七天
一、接口
1.语法:
1)是一种引用数据类型
2)由interface来定义(没有class关键字)
3)只能包含常量和抽象方法(默认权限是public且默认常量和抽象方法,可以省略修饰符)
4)接口不能被实例化
5)接口是需要被实现,实现类:必须重写所有抽象方法
--重写接口的方法时,访问权限必须设计为public的
6)一个类可以实现多个接口
--若又继承又实现时,应先继承后实现
7)接口可以继承接口(extends)
2.何时用:
接口的意义:
--封装部分派生类共有的属性和行为,实现多继承
--制定了一个标准,一种规范
3.用它的好处---------------第八天内容
补充:
1.类和类-----------------继承extends
接口和接口-----------继承extends
类和接口--------------实现implements
2.接口可以向上造型
第八天
一、多态
1.表现：
1.同一个对象被造型为不同的类型时,有不同的功能
--对象的多态：
我(学生、儿子、哥哥)、你（老师、母亲）、水（气态、液态、固态）......-----------所有对象都是多态的
2.同一个类型的引用指向不同的对象时,有不同的实现
--行为的多态：move(),getImage(),getScore().....------------所有抽象方法都是多态的
2.向上造型/自动类型转换------代码复用
--超类的引用指向派生类的对象
--能点出来什么看引用
--能造型成为的数据类型有:超类+所实现的接口
3.强制类型转换,成功的条件只有如下两种:
--引用所指向的对象,就是该类型
--引用所指向的对象,实现了该接口或继承了该类
PS:强转时若不符合如上条件,则发生ClassCastException类型转换异常
1.建议:在强转之前先通过instanceof来判断引用的对象是否是该类型
2.何时需要强转?
想访问的属性/行为在超类中没有,必须强转;强转之前先instanceof判断
第九天
一、内存管理:由JVM管理
1.堆:
--存储new出来的对象(包括实例变量)
--垃圾:没有任何引用所指向的对象
垃圾回收器(GC)不定时到内存中清扫垃圾,回收的过程中透明的(看不到的),不一定一发现垃圾就立刻回收,通过调用System.gc()建议虚拟机尽快调度GC来回收
--实例变量的生命周期:
创建对象时存储在堆中,对象被回收时一并被回收
--内存泄漏:不再使用的对象没有被及时的回收,严重的泄漏会导致系统的崩溃
建议:不再使用对象应及时把引用设置为null
2.栈:
--存储正在调用的方法中的局部变量(包括方法的参数)
--调用方法时,会为该方法在栈中分配一块对应的栈帧,栈帧中存储局部变量(包括方法的参数),方法调用结束时,栈帧被自动清除,局部变量一并被清除
--局部变量的生命周期:
调用方法时存储在栈中,方法调用结束时,栈帧被自动清除,局部变量一并被清除
3.方法区:
--存储.class字节码文件(包括静态变量,所有方法)
--方法只有一份,
二、面向对象三大特征总结
1.封装:
1)类:封装对象的属性和行为
2)方法:封装的是具体的业务逻辑实现
3)访问控制修饰符:封装的是具体的访问权限
2.继承:
1)作用:代码复用
2)超类:所有派生类所共有的属性和行为
接口:部分派生类所共有的属性和行为
派生/实现类:派生类所特有的属性和行为
3)单一继承、多接口实现，具有传递性
3.多态:
1)行为多态:所有抽象方法都是多态的(通过重写来表现)
对象多态:所有的对象都是多态的(通过向上造型来表现)
2)重写、向上造型、强制类型转换、instanceof判断
补充:
1.实例变量和局部变量的区别：
实例变量：
--写在类中，方法外
--创建对象时存储在堆中,对象被回收时一并被回收
--有默认值
局部变量：
--写在方法中
--调用方法时存储在栈中,方法调用结束时,栈帧被自动清除,局部变量一并被清除
--没有默认值
2.面试题:
问:java是值传递,还是引用传递?
答:java中只有值传递,基本数据类型传递的是具体的数,引用数据类型传递的是地址值
3.文档注释
文档注释是功能性的注释,只在三个地方使用,分别是类上,方法上,常量上.
1)在类上使用时,用来说明当前类的设计目的和整体功能介绍
/** 作者必须写,建议用英文名 @author XKB see表示参考的哪个类 @see java.lang.String */2)在常量上使用时,用来说明该常量用于哪个方法
/** * sayGoodbye方法中使用的问候语 */ public static final String INFO = "再见!";3)在方法上使用时,用来说明参数和返回值(输入/**再按回车会自动生成注解@)
/** * 为指定的用户添加问候语 * @param name 指定用户的名字 * @return 含有问候语的字符串 */ public String sayGoodbye( String name ){ return INFO + name; }4.get/set
标签：Java,构造方法,--,面向对象,对象,超类,派生类,方法,第一阶段 来源： https://blog.csdn.net/CabbageTomato/article/details/122415851
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。