黑马程序员Java基础知识学习部分汇总

来源：互联网发布：手机登录淘宝卖家中心编辑：程序博客网时间：2024/06/05 05:46

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

黑马程序员Java基础知识学习部分汇总

1. Java中原生数据类型有8种：char,byte,int,short,long,float,double,boolean。

2.  覆盖：1，子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。2，静态只能覆盖静态。

3.  当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。

4.  java只支持单继承，不支持多继承。因为继承了多个父类如果有相同方法时，子类对象不确定运行哪一个。

5. 所谓多态，就是父类型的引用可以指向子类型的对象，或者接口类型的引用可以指向实现该接口的类的实例。一共有两种类型的强制类型转换：（1）向上类型转换：比如将Cat类型转换为Animal类型，即将子类型转换为父类型。对于向上类型转换，不需要显式指定。（2）向下类型转换：比如将Animal类型转换为Cat类型，即将父类型转换为子类型。对于向下类型转换，必须显式指定。

6. 子类继承父类（父类是抽象类）的情况下，该子类必须要实现父类中所定义的所有抽象方法；否则，该子类需要声明成一个抽象类。

7. 接口的地位等同于class，接口中的所有方法都是抽象方法。可以将接口看作特殊的抽象类，抽象类中可以有具体方法，也可以有抽象方法，而接口中只能有抽象方法，不能有具体方法。

8. 一个类可以实现接口，使用关键字implements表示。Java是单继承的，也就是说某个类的只能有唯一一个父类；一个类可以实现多个接口，多个接口之间使用逗号分隔。

9. final关键字修饰类，表示该类是一个终态类，即不能被继承；final修饰方法，表示该方法是一个终态方法，即不能被重写；final修饰属性，表示该属性不能被改写。

10. static关键字可以修饰属性，方法和类（具体使用不再介绍）。static代码块：静态代码块。它的作用是完成一些初始化工作。首先执行静态代码块，然后执行构造方法。静态代码块在类被加载的时候执行，而构造方法时在生成对象的时候执行；要想调用某个类来生成对象，首先需要将类加载到Java虚拟机（JVM）上，然后由JVM加载这个类来生成对象。类的静态代码块只会执行一次，是在类被加载的时候执行的。如果继承体系中既有构造方法，又有静态代码块，那么首先执行最顶层的类的静态代码块，一直执行到最底层类的静态代码块，然后再去执行最顶层的类的构造方法，一直执行到最底层类的构造方法。静态的方法只能访问静态的；非静态的方法可以访问一切。

11.abstract 关键字，和哪些关键字不能共存。final：被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。而抽象方法出现的就是需要被复写。static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。可是抽象方法运行没意义。

12.抽象类中是否有构造函数？有，抽象类是一个父类，要给子类提供实例的初始化。

13.接口中的成员都有固定修饰符。常量：public static final方法：public abstract

14.千万不要为了获取其他类的功能，简化代码而继承。必须是类与类之间有所属关系才可以继承。所属关系 is a。

15. 访问修饰符：

（1） public（公共的）：被public所修饰的属性和方法可以被所有的类访问。

（2） protected（受保护的）：被protected所修饰的属性和方法可以在类内部、相同包以及该类的子类所访问。

（3） private（私有的）：被private所修饰的属性和方法只能在该类内部使用。

（4）默认的（不加任何访问修饰符）：在类内部以及相同包下面的类所使用。

16. instanceof：判断某个对象是否是某个类的实例。语法形式：引用名 instanceof类名（接口名），返回一个boolean值。例如

People people = new Man();//Man类是People类的子类

System.out.println(people instanceof People);//结果为true，因为Man是People的子类，根据继承，子类就是父类，因此Man也可以看做是People的实例。

17. 相等性的比较（==）

（1）对于原生数据类型来说，比较的是左右两边的值是否相等。

（2）对于引用类型来说，比较左右两边的引用是否指向同一个对象，或者说左右两边的引用地址是否相同。

18. 当打印引用时，实际上会打印出引用所指对象的toString方法的返回值，因为每个类都直接或间接地继承自Object，而Object类中定义了toString()，因此每个类都有toString()这个方法。

19. equals()方法，该方法定义在Object类当中，因此Java中的每个类都具有该方法，对于Object类的equals()方法来说，它是判断调用equals方法的引用与传进来的引用是否一致，即这两个引用是否指向的是同一个对象。对于Object类的equals()方法来说，它等价于==。

关于以上讨论的代码如下：

package com.heima.exam;

publicclass ObjectTest {

publicstaticvoid main(String[] args)

{

Object object = new Object();

System.out.println(object);

System.out.println(object.toString());

System.out.println("----------------");

String str = "aaa";

System.out.println(str);

System.out.println(str.toString());

System.out.println("----------------");

Object object1 = new Object();

Object object2 = new Object();

System.out.println(object1 == object2);

System.out.println("----------------");

Object object3 = new Object();

Object object4 = new Object();

System.out.println(object.equals(object4));

System.out.println(object.equals(object3));

System.out.println("-----------------");

Student student = new Student();

System.out.println(student);

System.out.println(student.toString());

}

class Studentextends Object

{

public String toString()

{

return"Hello World";

}

20. 对于String类的equals方法来说，它是判断当前字符串与传进来的字符串的内容是否一致。对于String对象的相等性判断来说，使用equals方法，而不是使用==。String是常量，其对象一旦创建完毕就无法改变。当使用+拼接字符串时，会生成新的String对象，而不是向原有的String对象追加内容。

String Pool是字符串池，它存在栈中。new String(“a”)创建新对象，它存放在堆中。”a”.intern()返回在字符串池中的”a”对象。否则，添加到池中，再返回地址。s.intern()==t.intern()成立，当且仅当s.equals(t);

String s = “hello world”;//采用字面值方式赋值。它执行的步骤是

（1）查找String Pool中是否存在”hello world”这个对象，如果不存在，则在String Pool中创建一个”hello world”对象，然后将String Pool中的这个”hello world”对象的地址返回来，赋给引用变量s，这样s会指向String Pool中的这个”hello world”字符串对象。

（2）如果存在，则不创建任何对象，直接将String Pool中的这个”hello world”对象地址返回来，赋给s引用。

String s = new String(“hello world”);//它的执行步骤是

（1）首先在String Pool中查找有没有”hello world”这个字符串对象，如果有，则不在String Pool中再去创建”hello world”这个对象了，直接在堆中创建一个”hello world”字符串对象，然后将堆中的这个”hello world”对象的地址返回来，赋给s引用，导致s指向了堆中创建的这个”hello world”字符串对象。

（2）如果没有，则首先在String Pool中创建一个”hello world”对象，再在堆中创建一个”hello world”对象，然后将堆中的这个”hello world”对象的地址返回来，赋给s引用，导致了s指向了堆中所创建的这个”hello world”对象。

package com.heima.exam;

publicclass StringTest {

publicstaticvoid main(String[] args)

{

String str = new String("aaa");

String str2 = new String("aaa");

System.out.println(str == str2);

System.out.println("----------------");

String str3 = "bbb";

String str4 = "bbb";

System.out.println(str3 == str4);

System.out.println("----------------");

String str5 = new String("ccc");

String str6 = "ccc";

System.out.println(str5 == str6);

System.out.println("----------------");

String s = "hello";

String s1 = "hel";

String s2 = "lo";

System.out.println(s == s1 + s2);

System.out.println("----------------");

System.out.println(s =="hel" + "lo");

String str7 = new String("aa");

String str8 = new String("aa");

System.out.println(str7.equals(str8));

String str9 = "aa";

String str1 = "aa";

System.out.println(str9.equals(str1));

System.out.println("-----------------");

}

21. 内部类共分为4种

（1）静态内部类：只能访问外部类的静态成员变量与静态方法，生成静态内部类对象的方式为：OutClass.InnerClass inner = new OuterClass.InnerClass();

（2）成员内部类：可以访问外部类的静态与非静态的方法与成员变量。生成成员内部类对象的方式为：OuterClass.InnerClass inner = new OuterClass().new InnerClass();

（3）局部内部类：定义在方法当中，只能访问方法中声明的final类型的变量，举例如下：

class LocalInner

{

public void doSomething()

{

final int a = 4;

class Inner3

{

public void test()

{

System.out.println(a);

}

new Inner3().test();

}

（4）匿名内部类：匿名内部类会隐式地继承一个父类或实现一个接口。它的访问权限与成员内部类相同。定义方式如下：

String str = test.get(new Date()

{

public String toLocaleString()

{

return "hello world";

}

});