冰冻三尺非一日之寒,滴水石穿非一日之功
打好基础是关键，笔者准备老老实实搞搞基础了，不仅为了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{}只执行一次。
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
