Java基础

1.重载(overload)：

<1>重载只能是形参个数不同或类型不同。若方法同名、返回类型不同，则不构成重载，而是犯了同名错误。

 

2.内存：

<1>代码在代码段里，全局变量或静态变量在数据段，局部变量在栈里，new出来的东西在堆里。

<2>return返回来的数据存放在栈里。

<3>字符串常量也是存放在数据段里。

 

3.static：

<1>在staic方法内访问非static属性，必须先new一个对象，通过对象来操作非static属性。若访问static属性，则可以直接访问。

<2>在static方法内调用非statci方法，必须先new一个对象，通过对象来调用这个非static方法。若是static方法，则可以直接调用。

4.包(package)：

<1>包是为了解决类名冲突的问题。

<2>包的名字约定俗成的取把公司域名倒过来。

<3>package语句必须放在程序的第一句，若缺省package语句，则视为无名包，这样的类叫裸体类。

<4>package com.sxt;则该程序中所有的类应该位于./com/sxt下。

<5>如果不用import语句引入包，则要用该包内的类时，需把类名写完整，如上，com.sxt.cat(cat是一个类)。

<6>import com.sxt.*引入包内的所有类。

<7>访问同一个包里的类不需要引入。

<8>包外的类想访问包里的类时，包内的class文件的最上层的包的父目录必须位于classpath下。

          比如Java/com/sxt.cat.class,则当包外的内想访问cat.class时，Java这个父目录必须位于classpath下。

<9>执行一个类，需要写全包名。

<10>java.lang这个包使用时不需要引入，其他的包必须引入。

<11>打jar包，先进入要打jar包文件所在的目录，然后执行jar -cvf  (起名).jar *.*(*.*:当前目录的所有文件以及子目录中的所有文件)

<12>可以将jar包放在classpath中，如.;d:/java/test.jar。

 

5.访问权限：

<1>修饰符            类内部             同一个包             子类             任何地方

<2>private          yes                

<3>default          yes                 yes

<4>protected      yes                 yes                   yes

<5>public            yes                 yes                   yes               yes

<6>对于class的权限修士只能用public和default

       public类在任何地方都可以访问

       default类只能被同一个包里类访问

<7>注意：<1>中的类内部的意思是定义类class{}尖括号内部

 

6.继承(inherit)：

<1>一个子类只能有一个基类，一个基类可以有无数个子类。

7.重写(override):

<1>子类可以对基类的方法重写。

<2>重写时方法的名字、返回类型、形参必须一样。

<3>重写方法不能比被重写方法具有更严格的访问权限。

 

8.变量赋值：

<1>任何变量，要么在声明时赋值，要么在方法内赋值。

 

9.继承中的构造方法(constractor)：

<1>子类的构造方法中必须调用基类的构造方法。

<2>子类可以在自己的构造方法中使用super(argument_list)来调用基类的构造方法，且super(argument_list)必须写在子类构造方法 的第一行。

<3>使用this(argument_list)来调用本类其他的构造方法。

<4>如果子类中没有显示的调用基类的构造方法，则系统自动调用基类无参的构造方法。

<5>如果子类中没有显示的调用基类的构造方法，基类中没有无参的构造方法，则编译出错。

 

10.object类的方法：

<1>垃圾收集装置会调用finalize()析构内存。

<2>Dog d = new Dog();

       System.out.println(d);相当于System.out.println(d.toString());建议所有的类重写toString这个方法，重写时一定要到API文档直接copy。

<3>Cat c1 = new Cat();

       Cat c2 = new Cat();

       System.out.println(c1 == c2);如果没用重写equals(),则会自动调用Object类中的equals()这个方法，比较的是两个对象的引用，除非c1和c2指向同一个对象，否则永远是false。

equals()具有自反性，对称性，传递性。

<4>String s1 = new String();

       String s2 = new String();

      System.out.println(s1 == s2);    结果为false

      System.out.println(s1.equals(s2));     结果为true

因为String类中重写了equals()方法，比较的字符串的内容。

 

11.对象转型：

<1>一个基类的引用可以"指向"其子类的对象。

<2>一个基类的引用不可以访问其子类新增的的成员变量。

即Animal a = new Animal(); a = new Dog();(Dog是Animal的子类)

但a只能访问Animal类中的成员，而不能访问Dog中新增的成员变量。

注意：a instanceof Dog返回的是true。因为a指向的是Dog类型，只不过它只能使用Animal的成员。

若要a可以访问Dog中新增的成员，则只需执行强制转换：Dog d1 = (Dog)a;

<3>可以使用："引用变量  instanceof 类名的方法 "语句来判断该引用变量所指向的对象是否属于该类或者该类的子类。 

<4>子类对象当做基类对象使用，称为向上转型，反之，称为向下转型。

 

12.多态(polymoph)：

<1>多态也叫动态绑定也叫迟绑定。

<2>多态的三个必要条件：

     一  要有继承，

     二  要有重写，

     三 父类引用指向子类对象。

当你使用该父类引用来调用方法时，调用的是子类中的方法，这就是所谓的多态。

 

13.抽象类(abstract)：

<1>可以将基类中的方法声明为抽象方法，抽象方法不用写如何实现，因为在子类中会被且必须被重写，除非子类中也将此方法声明为抽象方法。

<2>当一个类中含有抽象方法时，该类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写。

<3>抽象类不能被实例化，即不能用来new对象。

<4>抽象方法只需声明，不需要实现。

 

14.final：

<1>final修饰的变量的值不能被改变。

<2>final修饰的方法不能被重写。

<3>final修饰的类不能被继承。

 

15接口(interface)：

<1>接口是抽象方法和常量值定义的集合，只不过所有的方法的abstract和所有变量的static final没被显示的写出来。

<2>接口中声明的属性默认是public static final，也只能是public static final。

<3>接口中定义的方法默认是public abstract，也只能是public abstract。

<4>接口可以继承其他接口，并添加新的属性和方法。

<5>多个无关的类可以实现同一个接口。

<6>一个类可以实现多个接口。

<7>与继承关系类似，接口与实现类之间存在多态性。

<8>一个子类只可以继承一个基类但可以实现多个接口。

<9>接口可以继承接口。