前言:
这周过的很充实,因为对之前的内容没有很好理解本周一部分时间消化之前内容,经过三周的学习,对Java开始有了自己的认知,长路漫漫对自己的学习情况并不是很满意.
对本周内容做以下总结:
static的概念
关于static关键字-->被多个对象"共享,公用"的意思
特点:
1)被static修饰的成员(变量/方法)随着类的加载而加载,优先于对象存在!(对象创建:类名 对象名 = new 类名() ;)
某个类要先被编译产生-->类名.class-->类在运行的时候,加载过程要将静态的成员都先进入方法去的静态区中!
2)static和this不能共存!
this:代表是当前类对象的地址值引用--说明对象创建完毕,才能使用this,变量名-->访问成员变量(对象成员)
static:随着类的加载而加载,被static修饰的成员-->"类成员"
3)如果有一个变量体现被共享,被公用--->此时用"static"修饰
举例:
水杯中的水 (不行)
饮水机的水(可以被共享)
4)访问方式:
类成员-->被static修饰的,特有访问 方式
类名.变量名; //在访问本类中静态变量
类名,方法名() ; //在访问本类中的静态方法
注意:
我们所说的成员变量/成员方法--->默认 非静态的!
静态static的使用注意事项:
静态static的使用注意事项:
1)非静态的成员方法里面,皆可以访问静态的变量/方法,也可以访问非静态的变量/方法!
2)静态的方法只能访问静态的成员,不能访问静态的
记住:静态只能访问静态!
什么是java中的代码块?
Java中的代码块是一个{}包裹起来的内容?
分类:
局部代码块-->方法定义中 作用:限定局部变量的生命周期
构造代码块-->类的成员位置定义的{}
作用:在执行构造方法之前,如果存在构造代码块,先执行构造代码块,
然后在执行构造方法 ,就是给数据进行初始化的!
静态代码块-->类的成员位置定义的
static{
}
特点:跟类相关,类一加载,先执行,而且只执行一次(因为类就加载一次)
优先级最大
优先级:
静态代码块-->构造代码块-->构造方法!继承的概念
继承的概念:
将多个类的共性内容抽取到一个独立的类中,这个独立的类和这多个类产生一种关系"继承"
继承的格式:
class 父类名{}
class 子类名 extends 父类名{}
继承的好处:
1)可以提高代码的复用性
2)可以提高代码的后期维护
3)类与的类关系:继承关系 是多态的前提条件!
使用"继承"的时机:什么时候使用继承?
class A{
public void show(){}
public void show2(){}
}
class B{
public void show(){}
public void show3(){}
}
---->优化 class B extends A{}
不能为了使用部分功能就使用继承!
使用继承的前提条件:
如果一个类A是类B一种,或者是类B是类A的一种,才能使用继承,继承的核心思想体现出一种"is a"的关系
举例:
水果:
橘子
苹果
西瓜..
人:
工人
学生
军人
老师..
实际开发中:
所有的开发原则都必须遵循"低耦合,高内聚"
耦合:类和类中的关系越少越好,耦合性只能降低,不能避免!
内聚:解决某件事情(功能)的执行力!(一个类能够完成的尽量一个类完成,不能产生过多关系!)
继承的特点
继承的特点:
1)在java语言中,类与类的关系,只支持单继承
举例:
class Fu{}
class Fu2{}
class Zi extends Fu,Fu2{} 这种写法错误格式
2)类与类之间虽然不支持单继承,但是可以多继承!
继承的注意事项:
继承的注意事项:
1)子类继承父类,是可以继承父类所有东西,只不过父类的私有的属性以及方法只能在本类中访问子类是不能直接访问到的,但是可以间接的通过公共方法来访问!
2)子类继承父类,不能继承父类的构造方法(无参/有参构造),可以通过"super"来访问父类的构造方法!
继承关系中成员问题
继承关系中成员问题:
一个类的成员:
成员变量
成员方法
构造方法
1)子类继承父类,子类中 成员变量如果父类中的成员变量名称不一致的情况:比较简单,分别访问既可!
2)子类继承父类,如果子类的成员变量名称和父类的成员变量名称一致,如何访问呢?
a)先在子类的局部位置(子类的成员方法中定义变量:局部变量)找,如果存在,就使用
b)如果子类的局部位置没有,然后才在子类的成员位置找,如果存在,就使用
c)如果子类的成员位置没有,然后再父类的成员位置找,如果存在,就使用
d)如果父类的成员位置也没有,说明当前没有这个变量,就访问报错!
继承关系中:
子类继承父类,子类如何访问父类的构造方法?
通过super关键字
1)子类继承父类,不能继承父类的构造方法,但是可以通过super访问,子类的所有构造方法默认访问父亲的无参构造方法!
子类的构造方法的第一句话:都有super() ; 访问父类的无参构造方法
原因:
子类继承父类,可能用到父类的属性(成员变量)这些数据,必须让父类先初始化,然后子类才能初始化(构造方法,就是给数据初始化的)
这种过程---继承中"分层初始化"
2)永远建议把父类的无参构造方法给出来,可能会导致子类的构造方法报错!
考点:
代码块的优先级
静态代码块 > 构造代码块 > 构造方法
继承关系问题
子类的所有构造方法默认父类的无参构造方法,目的就是让父类初始化的,然后在子类初始化
继承关系中的构造方法的注意事项
继承关系中的构造方法的注意事项
子类继承父类,子类的所有构造方法第一句话都隐藏了默认 super() ;访问父类的无参构造方法
那么,如果父类中并没有给出无参构造方法,子类会出现什么情况?如何解决?
子类的所有构造方法都会报错!默认都要访问父类无参构造方法(默认机制)
解决方案:
1)自己手动给出父类的无参构造方法
2)不给出父类的无参构造方法,怎么解决?
让子类的所有构造方法都直接来访问父类的有参构造方法,只要父类初始化即可!
3)所有的子类的构造方法只要有一个让父类初始化即可!
在子类的无参构造方法中第一句话:this(xxx) ; 访问本类(子类)的有参构造方法
在通过子类的有参构造方法的第一句话:super(xxx) ;访问父亲的有构造方法-->父类先初始化完毕
方法重写和方法重载的区别
override和overload的区别
方法重载:
在定义方法的时候,为了提高功能的扩展性,同一个方法名,可以使用不同的参数进行传递!
方法名相同,参数列表不同,与返回值无关!
参数列表不同:
1)参数个数
2)参数类型
3)类型的先后顺序
方法重写:
是在继承关系中使用的;
子类继承父类,子类的功能想沿用父类的功能,同时使用自己的功能,子类出现了和父类一模一样的方法,--方法重写(覆盖/复写)
子类继承父类,如果要重写父类的功能,访问权限不能够更低,最起码跟父类的成员方法一致,要么永远public!
举例:
人:
eat() 吃的功能
员工:
work() 都需要工作
程序员也是员工 ---->日日夜夜敲带
项目奖经理也是员工---->吃饭喝酒谈项目
this和super的区别
概念区别
this:代表是当前类对象的地址值引用
super:代表父类的对象的地址值引用(父类的空间标识)
成员访问的区别:
this.变量名; 访问本类的成员变量
super.变量名; 访问父类的成员变量
this.方法名() ; 访问本类成员方法
super.方法名() ;访问的父类的成员方法
this() ; 访问本类的无参构造方法
this(xxx); 访问的本类的有参构造方法
super() ;访问的是父类的无参构造方法
super(xxx) ; 访问的是父类的有参构造方法
final修饰基本数据类型和修饰引用数据类型 的区别?
final修饰的引用数据类型,当前不能在开辟堆内存(不能重新new),里面的成员变量依然可以进行赋值
final修饰的基本数据类型,基本数据数据值不能在改变!
final,finalize,finally的区别?
final是一个状态修饰符.最终的,无法更改的!
修饰类,该类不能被继承
修饰成员方法,该方法不能被重写
修饰变量,此时变量是一个常量;
finalize:是一个方法名,是后面jvm当前确定堆内存中对象没有更多引用的时候,来通过垃圾器来调用进行回
收的方法!
finally:是关键字,是后面Java中去处理"异常"的一种格式:捕获异常
标准格式
try{
//可能出现问题代码
}catch(异常类名 变量名){
处理异常
}finally{
//释放相关的系统资源 (后面学习IO流,读取文件/写文件等等)
}
什么是抽象?
有抽象的方法的必须为抽象类
抽象类中不一定都是抽象方法!(部分的功能,抽象功能,必须让子类必须重写!)
抽象方法(成员方法)的格式:
权限修饰符 abstract 返回值类型 方法名(空参/带参) ;
抽象类的本质:
强制子类必须将父类的所有的抽象方法,必须重写(重写)
抽象类的特点:
不能实例化(不能new 创建对象)
抽象类的特点
抽象类的特点
1)成员变量:
可以是变量也可以自定义的常量
2)成员方法
既可以有抽象方法,也可以有非抽象方法!
3)构造方法
还存在继承关系,分层初始化--->先父类构造初始化,然后是子类构造初始化!
无参构造方法/有参构造方法都可以存在,目的都是为了数据进行初始化!
抽象abstract关键字不能和哪些关键字共存?
abstract不能和private公用:
被private修饰的只能在当前类访问,而abstract修饰的方法,它需要强制子类进行重写;
abstract不能和static共用:
abstract修饰的成员方法,需要被子类重写,还是抽象类多态进行实例化Fu fu= new Zi() ;
而static随着类的加载而加载(静态方法算不上重写),跟类相关的!
abstract不能和final公用:
被final修饰的成员方法不能被重写,而abstract修饰的成员方法,强制子类重写!
abstract:用在类上,标记这个类---抽象类
用在方法上,标记这个方法是一个抽象方法!
结合public使用居多
什么是接口?
接口体现的是这个事物本身不具备的功能,是一个额外的扩展功能!
如何定义接口
Java定义接口
interface 接口名{}
接口的子类(子实现类) implements 接口名{
强制子实现类必须将接口中所有抽象方法必须重写!(实现)
}
接口的特点:
1)接口不能实例化(不能创建对象)
2)接口如何实例化?
接口多态
接口名 对象名 = new 接口的子实现类名(); (前提:子实现类是非抽象的,就是一个具体类)
开发中:
接口名和子实现类的命名规范(开发项目中)
接口中的成员特点:
成员变量:只能是常量 存在默认修饰符 public static final
成员方法:(非静态):只能是抽象方法,存在默认修饰符 public abstract
在接口中是可以定义静态方法,必须有方法体(特例)
构造方法: 没有构造方法! 因为子实现类和接口的关系是implements实现关 系,只是将接口暴露的额外功能进行实现!
在Java中,
类与类:
继承关系,extends,而且只支持单继承,不支持多继承,但是可以多继承!
类与接口:
实现关系,implements,而且一个类继承另一个类的同时,是可以实现多个接口的!接口名和接口名直接逗号隔开
class LoverImpl extends Lover implements love,Study{}
接口与接口:
继承关系,extends,不仅支持单继承,也支持多继承,也可以多年继承!
:抽象类和接口的区别?
区别:
1)成员的区别
抽象类:
成员变量:既可以常量(定义final修饰的),也可以是变量
成员方法:既可以存在抽象方法,而且也可以存在非抽象方法
如果定义抽象方法,abstract不能省略!
构造方法:存在,无参构造/有参构造方法,让类的数据进行初始化(构造初始化)
接口:
成员变量:只能是常量,存在隐藏的默认修饰符:public static final
成员方法:只能是抽象方法
构造方法:没有
2)关系区别:
类与类:继承关系,只支持单继承,不支持多继承
类接口:实现关系,一个类继承另一个类的同时,可以实现多个接口
接口与接口:继承关系,可以单继承,也可以多继承以及多层继承
3)设计理念的区别
抽象类:有继承关系,抽象类不能创建对象,借助于抽象类多态(子类是具体类),进行实例化;
体现的核心思想:"is a"的关系
A类是B类的一种或者B类是A类的一种