学习Java时自己的一些重要理解

学习Java的小发现

1. 变量的可以分为2大类

        成员变量——这类变量属于类的数据成员

                ①<都是定义在类中，函数之外> 

                ②<它们都是随对象的存在而存在>   

                ③<而且都有默认初始化值>

        局部变量——这类变量属于函数的数据成员

                ①<都定义于函数体内>   

                ②<随函数的结束而释放>  

                ③<不会自动初始化为默值，自己手动初始化>

 

 

2. 不同于C++，在Java中，除了基本数据类型对象外，其余类类型的对象都要使用new在堆中创建

 

 

3. Java的引用

        在Java中，可以把引用看作是C/C++中受限的指针，它存的只是一个地址，存放于栈（stack）中，并指向堆（heap）中的某个对象。而它又不像C++的引用（纯粹只是一个对象的别名），一定要在定义引用的时候初始化，之后便不可改变其指向。Java中，你也可以修改该引用本身，即可以使它指向不同的对象   

    因此，Java中的引用的用途    

        ①可以使用它来改变该引用所指向的对象   

        ②通过定义一个引用，改变引用自身从使其指向不同的对象，然后再通过该引用处理不同的对象。  

 

 

4. super关键字——

        个人认为就像C++那样，super间接代表着基类的类名，并不像this那样代表着对象。

 

        而 super.variable; 与 super.menhod(); 与 super(); 这三种用法看起来就像是this的用法，这混淆了我们的视线。但其实super并不是代表着基类对象，而只是代表着基类类名，因此super就不是一个变量了，我们无法打印它或者使用某些操作符作用于它。

 

        结合自己学C++的经验，我的理解：

        上述super的用法只是Java的语法糖。

        在C++在子类中指定基类的数据成员、指定调用基类的方法、调用基类的构造函数这三种操作，可以这样做。

            ①  BaseClassName::variable;

            ②  BaseClassName::method( );

            ③  DerivedClassName( ) : BaseClassName( ) {  }

        这三种操作都对应于上面Java中super的三种用法

        Java没有作用域限定符（::），super代表基类名，若要限定使用基类的一些信息，只能是使用点（.）来限定。

        因此，

           ① 可以将 super.variable 理解为 使用基类名限定使用基类的某数据成员 即 super::varible

           ② 可以将 super.method() 理解为 使用基类名限定来调用基类的某个函数 即 super::method()

           ③ 可以将 super() 理解为 使用基类名来调用基类的构造函数 即 C++ 的 BaseClassName()

 

 

5. Java类中数据成员的初始化顺序

       构造代码块的初始化语句以及在类中定义数据成员的初始化语句，都会移入到构造函数中执行，而初始化的顺序是根据它们摆放的顺序有关

 

情况1: 

public class Test1 {

	public int i = 101;
	
	// 构造代码块
	{
		i = 120;
	}
	
	public static void main(String[] args) {
		Test1 t1 = new Test1();
		System.out.println( t1.i );
	}
}

 

   以上代码输出的的结果是120，定义 i 时的初始化语句与构造代码块中对 i 赋值的语句都会移入到Test1()中

 

public Test1(){
	i = 101;
	i = 120;
}

情况2:

public class Test1 {

	// 构造代码块
	{
		i = 120;
	}
	
	public int i = 101;
	
	public Test1(){
		i = 19;
	}
	public static void main(String[] args) {
		Test1 t1 = new Test1();
		System.out.println( t1.i );
	}
}

 

   以上代码输出的结果是 19 ，定义 i 时的初始化语句与构造代码快中对 i 赋值的语句都会移入到Test1()中

 

public Test1(){
	i = 120;
	i = 101;
	i = 19;
}

中

   从上面2种情况可以得出，移入到构造函数中的初始化语句都会先于构造函数中原来就有的初始化语句。
句

 

 

6. Java中static关键字

     static只能用于修饰类的数据成员与成员函数，而不能在成员函数内使用static关键字修饰局部变量。

     这是与C++的static有着极大区别的，C++的static可以用来修饰类的各种成员，也能修饰函数内的局部变量，C++的static修饰全局成员时，改变的是其可见性，不改变其生存期；而当用static来修饰局部变量时，会改变它的生存期。

     Java的static只会改变所修饰成员的生存期。

 

 

7. 静态代码块的执行时间

       在构造代码块前面加上static就是静态代码块了。

       静态代码块在类文件 .class 文件加载时执行，而 .class 文件加载是在第一次访问类信息而执行的。

 

8. Java中函数传递参数的机制

   从以前学过C++的经验来说，函数传递参数的方式可以分为三种：①以值传递②按地址传递 ③按引用传递

   方式①表示函数的形参是实参的副本，方式②③表示函数的形参显式或隐式是实参的地址。

   

       使用以值传递的方式传递实参给函数，函数操纵的只是实参的副本，因此无论在函数中如何修改形参，对于传递给函数的实参都不会有任何改变；使用按地址或引用传递，则在函数中对形参的修改，就等于对函数外部的实参的修改。

   

    不同于C++，Java只有以值传递的方式传递函数参数，不管是参数类型是基本数据类型还是引用类型。

 

以下的代码能告诉我们Java只能以值传递 ——

public class Test1 {

	public static void main(String[] args) {
		
		// 基本数据类型
		int i = 0;
		
		// 引用数据类型
		String str = new String("Original");
		
		System.out.println(i + " " + str);
		changeArgument(i , str);
		System.out.println( i + " " + str);
		
	}
	
	public static void changeArgument( int parameterA , String parameterB ){
		parameterA = 3;
		parameterB = new String("I change!!!!");
	}
	
}

只能

    这段代码打印的结果是两个 0 Original —— 因此，changeArgument()函数并没有改变两个实参的值。两个参数都是以值传递的。

 

 

9. 使用 + 或 += 连接字符串的问题

    在Java中，使用 + 或 += 连接字符串的时候，实际上是创建 StringBuilder 对象来调用 append() 方法来连接字符串。但在某个循环中 进行字符串连接的操作，这样会导致每次循环都创建 StringBuilder 对象，这样会降低效率。因此，我们可以在循环外面手动创建 StringBuilder 对象，并在循环中使用它连接字符串，从而可以优化性能。

 

 

10. Java中的接口

      接口 -- interface 就像是C++中的纯虚函数一样，它只有一个函数声明而没有实现，只有等待类使用者来实现该函数。

      我是这样来理解接口的：它代表着未实现的意向，即知道会去做某件事，但还不清楚如何去做这件事情。在Java编程中，我们可以使用接口来制定一些接口规范，这样使程序看起来会更清晰，但不能滥用接口。