------- <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 Student extends 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";
}
});