day01继承&抽象类
第一章 匿名对象
匿名对象:只创建对象,但是不用变量接收
正常: Dog d = new Dog(); 匿名: new Dog();
匿名的特点:只能使用一次,每次使用匿名对象时,实际都是创建了一个新的对象
匿名对象也可以作为方法的参数和返回值
第二章 继承
继承:在Java中,类的继承是指在一个现有类的基础上去构建一个新的类,构建 出来的新类被称作子类,现有类被称作父 类,子类会自动拥有父类所有可 继承的属性和方法。
2.1 格式
public class 父类{
....
}
public class 子类 extends 父类{
只要继承父类,那么子类就可以拥有并直接使用,父类中所有非私有的成员私有也可以使用,只是不能直接调用,可以间接使用
}
2.2 继承的好处
a.提高代码的复用性
b.为多态提供了前提
2.3 继承后的特点——成员变量**********
a.如果子父类的成员变量名不同,那么写哪个成员变量就是访问哪个成员变量
b.如果子父类的成员变量名相同,那么根据就近原则,优先访问子类的成员变量
2.4 继承后的特点——成员方法**********
a.如果子父类的成员方法名不同,那么写哪个成员方法,就调用哪个成员方法
b.如果子父类的成员方法名相同,那么根据就近原则,优先调用子类的成员方法
2.5 重写的应用************************
在实际开发中,我们不会定义子父类重名的成员变量的
但是在实际开发中,我们肯定会定义和父类重名的成员方法
2.51方法的重载与重写
方法的重载:在同一个类中,方法名一样,参数列表不一样
方法的重写:在子父类中,子类中的方法和父类中的方法,除了方法体其他一模一样,子类中的该方法我们称为重写的方法
当子类继承父类后,发现父类某些方法功能比较low时,那么子类需要重写该方法
如果重写方法中某些功能父类已经存在,只要使用super.方法名()调用父类的方法即可
2.6 注意事项
重写也叫覆盖,也叫覆写,英文名叫override
a.子类方法的权限 >= 父类方法的权限
public protected default private
b.重写时,除了权限和方法体,其他必须一模一样
c.私有方法不能被重写
2.7 继承后的特点——构造方法
构造方法是不能被子类继承的!!!
在子类的任意构造方法的第一行,有这么一句代码,super(),代表调用父类的无参构造
2.8 super和this
父类空间优先于子类对象产生(内存图)
this 表示整个子类对象
super 表示子类对象中父类的空间
2.9 this和super可以访问构造方法
this(参数):调用本类的构造方法
super(参数);调用父类的构造方法
2.10 继承的特点*****
a.Java只支持单继承,不支持多继承(一个子类只能有一个父类) b.Java支持多层继承(子类只能有一个父类,父类也可以有自己的父类) c.Java中有一个类,它是所有类的直接或者间接的父类,称为根类(Object类)
第三章 抽象类
3.1 抽象类的概述
抽象方法: 只有方法的声明(头部),没有方法实现(方法体)
抽象类: 只要该类含有抽象方法,那么该类一定是一个抽象类
3.2 abstract使用格式
抽象方法 public abstract 返回值类型 方法名(参数列表);
抽象类
public abstract class 类名{
}
抽象类的使用
a.抽象类不能创建对象!!!!!
b.抽象类天生就是做父类用的
c.子类继承抽象类后,需要重写所有的抽象方法后,子类才能创建对象,否 则子类还是一个抽象类
3.3 注意事项
抽象类不能创建对象
抽象是有构造的,而是给子类调用的
抽象类可以有抽象方法,也可以没有抽象方法
抽象类的子类,必须重写抽象父类中所有的抽象方法
day02_接口&多态
一. 接口
接口是方法的集合
1.1 接口中的各种方法
a.抽象方法(jdk1.7)
b.默认方法和静态方法(jdk1.8)
c.私有方法(jdk1.9)
1.2 格式
public interface 接口名{
//接口中只能定义方法
//1.抽象方法
public abstract void abs1();
2.默认方法(default)
public default void show(){
....
}
3.静态方法(static)
public static void show2{
}
}
1.3 接口的使用–实现
a.接口不能创建对象(接口中没有构造方法)
b.接口也是天生做父类的,让实现类实现它
1.4 接口中各种方法的使用
a.接口中的所有抽象方法,实现类必须重写
b.接口中的默认方法 实现类可以选择性重写
c.静态方法没有继承的概念
1.5 接口的多实现
一个类可以实现多个接口
a.实现类必须重写所有抽象方法(如果接口中方法重名,只需重写一次)
b.实现类可以选择重写接口中所有默认方法
如果某个接口中默认方法相同,那么实现类中必须重写一次
c.静态方法没有重写,也不需要重写,因为静态方法通过接口名去直接调用
public class 类名 implements 接口1,接口2{}
1.6 继承和实现的优先级问题
一个类可以继承一个父类同事实现多个接口(先写继承再写实现)
如果父类的正常方法和接口默认方法中方法重名时,子类可以不重写,默认使用父类的方法
1.7 了解接口的多继承
类和类之间,称为继承,单继承
类和接口之间称为实现,多实现
接口和接口之间称为继承,多继承
1.8 接口中其他成员的特点
接口中不能有普通的成员变量,可以有特殊的“成员变量”,我们称为常量
常量必须有三个修饰符修饰:public static final 数据类型 常量名= 值;
接口中没有构造方法
接口中没有静态代码块
1.9 instanceof 关键字
二 多态
1.什么是多态:一个对象的多种状态
2.多态的前提和体现
多态有两个前提
a.必须有继承或者实现
b.必须有方法的重写
多态的体现:
父类类型的变量 指向了 子类类型的对象
3.多态的代码实现
直接多态
Animal a = new Dog();
间接多态
Dog d = new Dog();
Aaimal a = d;
方法调用时的多态
method(new Dog());
public static void method(Animal a){}
4.多态调用时的特点
编译时看父类,运行时看子类
5.多态的好处
使用父类类型的变量可以接收任何一个子类对象
提高代码的灵活性(扩展性)
6.多态的弊端
多态只能调用父类共有的方法,不能调用字类特有的方法
7.多态弊端的解决方案–转型
向上转型:子类-->父类 Animal an = new Dog();
向下转型: 父类-->子类 Dog d = (Dog)an;
当多态需要调用子父类共有方法是,不需要转型
当多态需要调用子类特有方法是,需要向下转型,转成子类
8.转型是出现的问题
类型转换异常:ClassCastException
如实际上是狗类转换为猫类
9.instanceof 关键字
instanceof :是不是谁的对象
用法: boolean b = 对象名 instanceof 类名
Animal an = new Cat();
if(an instanceof Dog){}
day03
一 final关键字
1.final关键字 :最终的,不可变的
a.final修饰类:'太监类-----被final修饰的类不能被其他类继承'
b.final修饰'方法
被final修饰的方法,子类可以继承但是不能重写
c.final修饰'局部变量(局部变量)''
被final修饰的局部变量只能赋值一次
d.final修饰'引用类型的变量'
被final修饰的局部变量(引用类型)只能赋值一次'地址'
final Dog dd = new Dog();
dd = new Dog();//报错,因为企图修改dd中的地址
Dog ddd = dd;
ddd = new Dog();//不报错,因为ddd没有被final修饰
e.final修饰'成员变量'
被final修饰的成员变量'只能赋值一次'
两种方式:a."定义时赋值 ' b.定义时不赋值,在'构造方法中赋值'
二 static 关键字
1.static 的含义:
static叫静态关键字
能修饰的成员'成员变量和成员方法'
特点:a.'被static修饰的成员,不属于对象,属于整个类'
b.'被static修饰的成员,通过类名就可以直接调用'
2.static 修饰成员变量
被static修饰的成员变量:'不属于对象,属于整个类'
该成员变量,不建议通过对象访问('也可以,强行写'),"建议直接类名访问"
3.static 修饰成员方法
a.该成员方法也不属于对象,属于类
b.该成员方法可以通过类名直接调用
4.总结 static 成员的用法
static可以修饰成员变量:类变量
可以通过 "对象名.静态变量名"
建议通过 "类名.静态成员变量名"
static修饰成员方法:"类方法,静态方法"
可以通过 "对象名.静态成员方法名()"
建议通过 "类名.静态成员方法名()"
总结:"静态成员优先于对象存在,在没有对象的情况下,也可以通过类名调用"
静态和非静态的访问问题
a."静态 可以访问 静态"
b."非静态 可以访问 非静态"
c.静态 '不可以访问 非静态'(非静态在创建对象后才存在,而静态是 属于类的,没有对象也可以通过类访问)
d."非静态 可以访问 静态"
5.静态代码块
----静态优先于对象存在----
由static修饰的代码块
格式 :
static{
静态代码块...
}
位置:类中方法外
特点:"当第一次使用该类(加载到内存时),该类的静态代码块会自动执行(只 执行一次),而且静态代码块有限与构造方法执行的"
作用:用给类初始化的,比如,加载驱动,读取配置文件等...
三 权限修饰符
a.java的四种修饰符
权限从大到小依次为:
public(公共的) protected(受保护的)default(默认的,空的,不写) private(私有的)
b.开发中用到的权限
i.成员变量,使用 private
ii.成员方法,使用 public
iii.构造方法,使用 public
四 内部类
1.什么是内部类
2.成员内部类
定义在外部类的类中方法外
特点:a."内部类中可以无条件的访问外部类中的任何成员"
b.如何创建内部类对象
外部类名.内部类名 对象名 = new 外部类().new 内部类();
3.扩展:局部内部类
定义在方法中,只能在局部使用
4.【重点】匿名内部类
是一种快速创建对象的语法
匿名内部类,可以帮助我们"快速创建一个类的子类对象或者一个接口的实现对象"
5.总结:匿名内部类的使用格式
"快速创建抽象类的子类对象"
抽象类名 对象名 = new 抽象类名(){
重写抽象类中个的抽象方法
};
"快速创建接口的实现类对象"
接口名 对象名 = new 借口名(){
重写接口中的抽象方法
};
五 引用类型使用总结
基本类型可以做的引用类型也可以做
引用类型作为方法的参数和返回值
day04_Object
一 Object类
1.Object介绍
包:java.lang
作用:所有类的根类(包括数组)它一共11个方法
2.toString方法
public String toString();
作用:返回对象的字符串表示
默认表示格式:"包名.类名@地址值"
开发中会重写toString,返回的不是地址值,而是返回"对象的所有属性值"
自动生成toString的方法:alt+INS,选择需要的成员属性即可
"注意:我们直接使用输出语句输出对象名的时候,其实通过该对象调用了 其toString()方法"
3.equals方法
public boolean equals(Object obj);
作用:判断其他某个对象是否与此对象"相等"。
Object 中 equals 方法默认比较的的是"地址值!
开发中:我们通常会重写equals,比较的不是地址值,而是两个对象的所有属性,只有所有属性都相等,两个对象才相等,才会返回true
自动生成equals的方法:alt+INS,选择需要的成员属性即可
4.总结
==与equals的区别
a.基本类型 只有==,比较的是数值
b.引用类型
对象1 == 对象2 比较就是地址
对象.equals(对象2) "如果没有重写,比较的是地址"
"如果重写,比较的是属性值"
二 时间日期类
1.Date类
包:"java.util"
作用:类Date表示特定的瞬间,精确到毫秒
构造:
public Date();"当前的系统时间"
public Date(long time);创建一个距离标准时间time毫秒后的时 间 "标准时间:1970-01-01 00:00:00"英国
"标准时间:1970-01-01 08:00:00"(北京时间)
常用方法:
public long getTime();获取Date对象的毫秒值
public void setTime(long time);设置Date对象的毫秒值
2.DateFormat类
包:java.text
作用:格式化Date对象 把Date对象转化成我们喜欢的格式的字符串
构造:DateFormat是一个抽象类 我们使用的是它的子类
"SimpleDateFormat"
包:java.text
构造方法:
public SimpleDateFormat(String pattern);创建一个 日期对象,指定格式化模式
成员方法:
public String format(Date date);将一个Date对象 转化成字符串
publicDate parse(String time);将字符串解析为Date
SimpleDateFormat常用的格式规则为:
y | 年 |
---|---|
M | 月 |
d | 日 |
H | 时 |
m | 分 |
s | 秒 |
3.Calendar
包:java.util
作用:代表某个瞬间,精确到毫秒
构造:Calendar是一个抽象类
a.获取方式:
通过一个静态方法获取
public static Calendar getInstance();获取一个 Calendar 的实例对象(默认语言是时区)
b.常用方法:
1. public int get(int field);获取日历对象中某一个字段的值
Calendar c = Calendar.getInstance();
例: int year = c.get(Calendar.YEAR);
2. public void set(field int value);修改某一个字段的值
3. public void add(field int value);增加某一个字段的值;
4. public Date getTime();将日历对象转为日期对象
3.Math
包:"java.lang"
作用:包含用于执行基本数学运算的方法
构造:Math类的构造私有化,不允许任何人创建对象
成员方法:都是静态方法
8个方法: "Math._"
public static int abs(int a);获取绝对值的方法
int abs = Math.abs(1);
public static int max(int a,int b);获取最大值
public static int min(int a,int b);获取最小值
public static int round(float a);获取四舍五入值
public static double random(float a);获取随机小数
范围[0.0,1.0) '即包含0.0不包含1.0'
public static double ceil(double a);"向上取整"
public static double floor(double a);"向下取整"
public static double pow(double a,double b);"求次幂"
四 System类
包:java.lang
作用:包含一些有用的方法,而且不能创建对象
构造:System类构造私有化,不允许任何人创建对象
方法:两个静态方法
1 arraycopy(源数组,开始下标,目标数组,开始下标,长度);复制数组
2 exit(int code);退出JVM
public static long currentTimeMillis();获取当前系统时间的毫秒值
五 包装类
包装类的介绍
基本类型对应引用类型(基本数据类型的包装类)
char ->Character int->Integer
Integerd 构造和静态方法
3.自动拆箱和装箱的介绍*****************
装箱:把基本类型 转成 对应的包装类型
拆箱:把包装类型 转成 对应的基本类型
JDK1.5之后基本类型和包装类之间的运算,可以当做基本类型计算
4.基本类型与字符串之间的转化
基本类型-->String
转换方式
方式一:直接在数字后加一个空字符串
int number = 100;
String s1 = number + "";
方式二:通过String类静态方法valueOf()
String s2 = String.valueOf(number);
String-->基本类型
转换方式
方式一:先将字符串数字转成Integer,再调用valueOf()方法.
String s = "100";
Integer i = Integer.valueOf(s);
int x = i.intValue();
****方式二:"通过Integer静态方法parseInt()进行转换
int y = Integer.parseInt(s);
day05_异常&线程
一、异常
1.什么是异常
程序运行过程中出现的问题
2.异常的继承体系
Throwable:所有异常的根类
|-Error 错误(硬件问题)
|-Exception 异常(程序员问题)
|-编译时异常(CheckException):Exception及
其子类("RuntimeException除外)
在编译时就提示异常,称为编译时异常
|-运行时异常(RuntimeException):RuntimeException以及子类
在编译时不提示,运行时直接在控制台上打印异常信息
3.异常类中常用的三个方法
public void printStackTrace();"打印异常的详细信息"
("异常的类型,原因,位置") '常用'
public String getMessage();获取异常的信息(只有异常的原因)
public StringtoString();获取异常的类型和异常描述信息('不用')
4.异常的分类
i.编译时异常
Exception及其子类("RuntimeException除外)
在编译时就提示异常,称为编译时异常
ii.运行时异常
RuntimeException以及子类
在编译时不提示,运行时直接在控制台上打印异常信息
二、异常处理
1.模拟JVM抛出异常(关键字 throw)
格式:throw newXxx异常();
2.Objects类中提供的非空判断方法
Objects 是工具类(所有方法都是静态的)
Objects.requareNonNull(T obj){}
3.遇到异常的两种处理方式
1.throws声明抛出异常
给方法做声明的,声明方法内可能抛出异常,要求该方法的调用者处理
'格式':
public static void 方法名()throws XxxException,YyyException{
方法体;//
}
2.try…catch捕获异常
就是捕获异常对象,异常对象就不会向上抛出了
格式:
try{
可能抛出异常的代码
}catch(XxxException e){
//打印异常信息
e.printStackTrace();
}
其他代码块(不管有无异常都会执行)
4,[扩展1]catch代码块中三种常见的处理方式
1.直接打印异常(开发和测试阶段)
2.写到日志文件(上线阶段)
3.转换成运行时异常(数据库阶段使用)
5.[扩展]多个异常如何获取处理
public static void method01() throws XxException{
}
public static void method02() throws XxException{
}
public static void method03() throws XxException{
}
a.分别出理:一个try一个catch
public static void main(String[] args){
try{
method01();
}catch(XxxException xxx){
//处理
}
...
}
b.一个try多个catch
try{
method01();
method02();
method03();
}catch(XxxException xxx){
//处理
}catch(YyyException yyy){
//处理
}
...
"假设XxxException extends YyyException"
那么必须先捕获子类异常,再捕获父类异常
c.一次捕获一次处理 "开发中常用"
try{
method01();
method02();
method03();
}catch(Exception xxx){
//此处必须是所有可能异常的共同父类
}
.......
6.finally代码块
finally 必须要执行的代码
格式:
try{
可能出现异常的代码
}catch(Exception e){
处理异常的代码
}finally{
必须要执行的代码
一般用于释放资源的代码
释放资源:关闭流,关闭数据库连接,关闭网络连接
}
7.异常的注意事项
a.运行时异常,便一阶段不需要抛出,也不需要try..catch
b.子类重写后方法的异常,必须是 父类方法异常的子集
c.如果父类的方法没有抛出异常,那么子类重写方法是必须不能抛出,只能捕获
d.多个catch时,前面的异常必须是子类,后面的异常是父类
e.finally可以加,当有资源需要释放是添加finally
三、 自定义异常
1.为什么要自定义异常
因为JDK不能考虑到所有可能的问题
2.自定义异常的步骤
a.自定义异常必须是XXXException(命名)
b.自定义异常必须继承Exception或者RuntimeException
c.自定义异常必须提供至少两个构造(无参,带有异常信息的)
d.在适当的时候抛出自定义异常
四、多线程*************************************************************
1.并行和并发
并行:多个事件,在同一时刻同事发生
并发:多个事件,在同一时间段内同时发生(交替执行)
2.进程和线程
'进程:正在运行的程序
'线程:进程中的一个执行单元,完成某个功能的小模块
进程和线程的一些'区别'
进程拥有独立的内存(独立的栈空间和独立的堆空间)
线程拥有独立的栈和共享的堆
'线程调度'
一个CPU(单核),同一个时刻只能执行一句代码
什么是是线程调度:
CPU在不同的线程之间进行快速的切换
'线程调度分类'
a.分时调度:每个线程轮流执行一定时间
b.抢占式调度:每个线程随机获取CPU的时间
3.创建新的线程的方式一*************************************************************
API :一种方法是将类声明为Thread的子类
该类应重写Thread类的run方法,接下来可以分配并启动该子类的实例
步骤:
a.子类 继承Thread
b.子类 重写run方法
c.创建子类对象
d.启动线程 调用对象的start方法