冰冻三尺非一日之寒,滴水石穿非一日之功
打好基础是关键,笔者准备老老实实搞搞基础了,不仅为了7月份的实习面试,还是为了自我能力的提升,基础的重要性不可忽视。
牢骚发完了,进入正题吧。
1.用构造器进行初始化
- 构造器采用与类相同的名称,因此“每个方法首字母小写”的编码风格不适合用在构造器中
- 构造器是一种特殊类型的方法,因为它没有返回值。这与返回值为空(Void)不同。
- 默认构造器是没有形式参数的,他的作用是创建一个默认对象。如果类中没有构造器,那么编译器会自动帮你创建一个默认构造器。
- 但是,如果你在类中已经定义了一个构造器(无论是否有参数),那么编译器就不会帮你自动创建默认构造器了。
2.方法重载
为了让方法名相同而让形式参数不同(独一无二的参数类型)的构造器同时存在,必须用到方法重载。要对明显相同的概念使用了不同的名字,就会令人困惑,好在有了方法重载,可以为二者使用了相同的名字。
class NBA{
public NBA() {
System.out.println("这是无参构造");
}
public NBA(String team) {
System.out.println("这是有一个参数的构造"+team);
}
}
public class Demo1 {
public static void main(String[] args) {
new NBA();
new NBA("火箭");
}
}
2.1基本类型的重载
如果传入的数据类型(实参)小于方法中声明的形参类型,那么数据类型就会被提升。反之,需要将实参进行窄化。
2.2不能以返回值区分方法重载
有时候,我们并不关心方法的返回值,
int i(){
return 0;
}
float i(){
return '0';
}
编译不过去。当调用i()时,Java并不知道该调用哪个
this关键字
this关键字只能在方法内部使用,表示对“调用方法的那个对象”的引用。如果在方法内部调用同一个类中的另一个方法时,就不必用this,直接调用即可
只有当需要明确指出对当前对象的引用时,才需要使用this关键字。
class NBA {
int i;
public NBA increment() {
i++;
return this;
}
public void print() {
System.out.println(i);
}
}
public class Demo1 {
public static void main(String[] args) {
new NBA().increment().increment().print();
}
}
在构造器中调用构造器
class NBA {
int i;
NBA(String team){
System.out.println(team);
}
NBA(int year){
System.out.println(year);
}
NBA(String team,int year){
this(team); //只能在构造器的第一行调用其它构造器
// this(year); //在构造器中调用1个的构造器
}
public void print() {
// this();//在非构造器中不能调用构造器
System.out.println(i);
}
}
public class Demo1 {
public static void main(String[] args) {
new NBA("火箭", 20);
}
}
- 尽管this可以调用一个构造器,但却不能调用二个
- 构造器必须置于最始处
- 除构造器之外,编译器禁止在其他任何方法中调用构造器。
static含义
static方法就是没有this的方法,在static方法的内部不能调用非静态方法(类加载器将会去加载类,而static修饰的方法是属于类的,因此,static方法同时也被加载,而非静态方法需要对象,此时还没有生成对象,所以static方法的内部不能调用非静态方法),反之,可行。在没有创建对象的前提下,仅仅通过类本身来调用static方法,这正是static主要用途。static方法可以访问其他static域和方法。
面向对象的思想是“向对象发送消息”,而由于static方法就是没有this的方法,所以并不是面向对象思想,因此,尽量少用static.
清理:终结处理和垃圾回收
- 在Java中,对象并非总是被垃圾回收
- 垃圾回收只与内存有关
- 如果jvm并未面临内存耗尽的情形,它就不会去执行垃圾回收以恢复内存的。
关于垃圾回收机制建议看《深入理解Java虚拟机》,这本书是我的下月计划。
成员初始化
java尽力保证:所有变量在使用前都能得到恰到的初始化。
而类的数据成员,即字段,都会有一个初始值。
class A{}
class NBA {
int i;
float f;
boolean b;
char c;
byte by;
short s;
long l;
double d;
A a;
void print(){
System.out.println(i); // 0
System.out.println(f); // 0.0
System.out.println(b); //false
System.out.println(c); //
System.out.println(by); // 0
System.out.println(s); // 0
System.out.println(l); // 0
System.out.println(d); // 0.0
System.out.println(a); // null
}
}
public class Demo1 {
public static void main(String[] args) {
new NBA().print();
}
}
初始化顺序
在类的内部,变量定义的先后顺序决定了初始化的顺序。即使变量定义散布于方法定义(包括构造器)之间,它们也会在任何方法被调用之前得到初始化。
class CBA{
CBA(String team){
System.out.println(team);
}
}
class NBA {
CBA cba = new CBA("上海哔哩哔哩"); //在构造器方法前
NBA(){
System.out.println("NBA构造器");
}
CBA cba2 = new CBA("浙江稠州银行"); //在构造器方法后
void f(){
System.out.println("普通方法");
}
CBA cba3 = new CBA("北京首钢");//在普通方法后
}
public class Demo1 {
public static void main(String[] args) {
new NBA().f();
}
}
输出:
上海哔哩哔哩
浙江稠州银行
北京首钢
NBA构造器
普通方法
静态数据的初始化
无论创建多少个对象,静态数据都只占用一份存储区域。static关键字不能应用于局部变量,因此它只能作用于域。
class WCBA{
WCBA(){
System.out.println("WCBA构造器");
}
}
class CBA{
static WCBA wcba= new WCBA();
CBA(String team){
System.out.println(team);
}
}
class NBA {
NBA(){
System.out.println("NBA构造器");
}
}
public class Demo1 {
public static void main(String[] args) {
new CBA("浙江");
new NBA();
}
static CBA cba3=new CBA("上海");
}
结果:
WCBA构造器
上海
浙江
NBA构造器
初始化的顺序是先静态对象(如果他们尚未因前面的对象创建过程而被初始化),然后是非静态对象。
在main()方法执行之前,先执行静态对象,也就是cba3,需要加载CBA类,同理,CBA类取加载WCBA,执行WCBA的构造,再执行CBA构造,最后执行main方法,值得注意的是,new CBA("浙江"),直接输出浙江二字,并没有再去执行static WCBA wcba= new WCBA();充分说明了static只执行一次。
显示的静态初始化
静态块也执行一次,当首次生成该类对象时,或者首次访问属于那个类的静态数据成员时。
class CBA{
CBA(String team){
System.out.println(team);
}
void f(){
System.out.println("CBA");
}
}
class NBA {
static CBA cba1;
static CBA cba2;
static{
cba1=new CBA("上海bilibili");
cba2=new CBA("上海bilibili2");
}
NBA(){
System.out.println("NBA构造器");
}
}
public class Demo1 {
public static void main(String[] args) {
NBA.cba1.f();
//new NBA().cba1.f();这句话也行
}
}
输出:
上海bilibili
上海bilibili2
CBA
非静态实例初始化
用于初始化每个对象的非静态变量
class CBA{
CBA(String team){
System.out.println(team);
}
void f(){
System.out.println("CBA");
}
}
class NBA {
CBA cba1;
CBA cba2;
{
cba1=new CBA("上海bilibili");
cba2=new CBA("上海bilibili2");
}
}
public class Demo1 {
public static void main(String[] args) {
new NBA().cba1.f();
new NBA().cba1.f();
}
}
输出:
上海bilibili
上海bilibili2
CBA
上海bilibili
上海bilibili2
CBA
可以看到,{}块每次都会执行,而static{}只执行一次。