黑马程序员--Java基础总结

-------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
1、 为什么需要配置path，什么时候需要classpath?

当执行javac和Java命令时，需要每次都进入到bin目录下才能执行，根据windows系统在查找可执行程序的原理， 可以将Java工具 所在的路径定义到path环境变量中，让系统帮我们去查找需要运行的程序，因此，配置path是为了更方便的去执行程序。

要在当前路径下执行其他路径下.class的文件时，就需要用到classpath，设置了classpath后，它会将Java运行文件的路径告诉系统，虚拟机在执行时会按照设定的类文件路径去查找并运行。

2、变量有什么用？为什么要定义变量？什么时候用？

答：变量的作用：用来存储数据。

 为什么要定义变量：用来不断的存放同一类型的常量，并可以重复使用

3、&和&&的区别?

&和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。

&&会出现短路，如果可以通过第一个表达式判断出整个表达式的结果，则不继续后面表达式的运算；只能操作boolean类型数据；

&不会出现短路，将整个表达式都运算。既可以操作boolean数据还可以操作数。

4、数据类型：

(1)基本数据类型(4类8种)：

整数类型：byte、short、int、long

浮点数类型：float、double

字符类型：char

布尔类型：boolean(ture false)

(2)引用数据类型：

类、接口、数组

5、Java 的 char型变量是两个字节，可以存储汉字！！

char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所以，char型变量中当然可以存储汉字啦。不

过，如果某个特殊的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能存储这个特殊汉字。

补充说明：unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。

6、内存结构：

Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，

有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈内存:用于存储局部变量，当数据使用完，所占空间会自动释放。

堆内存:数组和对象，通过new建立的实例都存放在堆内存中。每一个实体都有内存地址值,实体中的变量都有默认初始化值,实体不在被使用，会在不确定的时间内被垃圾回收器回收

方法区，本地方法区，寄存器

7、类与对象之间的关系：

类：是对事物的描述。 就是将对象中共性的内容 不断抽取出来的一个抽象描述。

对象：是该类事物具体的实体

new 对象new的是字节码文件对象，在源代码可以没有person类，但是必须有person类的字节码文件

实际使用的是person的字节码文件装载进内存并用他产生了一个堆内存实体

对象生命周期结束

Java虚拟机的垃圾回收线程回收对象的内存，一般只要Java程序中没有变量引用某个对象，该对象的生命周期结束，因此可以通过控制变量的生命周期来控制对象的生命周期。

对象生命周期的开始

对象生命周期开始时，需要为对象分配内存（在内存运行时数据区的堆区中为对象分配内存），并且初始化它的实例变量；

所谓的面向对象就是说：看到实体，对实体进行描述，创建实体对象，使用实体。

8、面向对象特征：

封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式

继承: 多个类中存在相同属性和行为时，将这些内容取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

多态: 一个对象在程序不同运行时刻代表的多种状态，父类或者接口的引用指向子类对象。

9、static关键字：
用于修饰成员（成员变量和成员函数）
被修饰后的成员具备以下特点：
随着类的加载而加载
优先于对象存在
被所有对象所共享
可以直接被类名调用
使用注意
静态方法只能访问静态成员
静态方法中不可以写this，super关键字

10、成员变量和局部变量的区别：

（1）定义的位置。

局部变量定义在函数中，语句内。

成员变量定义在类中。

（2）内存中的位置。

局部变量存储在栈内存中。

成员变量存储在堆内存中。

（3） 初始化值。

局部变量没有默认初始化值，必须赋值才可以使用。

成员变量有默认初始化值。

（4） 生命周期。

局部变量一旦作用区域结束，就立刻释放。

成员变量也称为实例(对象)变量,随着对象的出现而出现。随着对象的被回收而释放。

11、继承的特点

Java中只支持单继承。并不直接支持多继承。

单继承：一个子类只能有一个父类。 

多继承：一个子类可以有多个父类。不直接支持，对其进行改良。 

继承层次多了，就形成了继承体系。

体系就是不断向上抽取而来的。

在使用一个体系的时候，先参阅最顶层类，了解体系的最基本功能。

使用时，创建该体系最底层类的对象。

看顶层，用底层。

什么时候使用继承呢？

当A类是属于B类中的一种时，就使用继承。
继承的好处：

1，提高了代码的复用性。

2，让类与类之间产生了关系，为多态特征提供了前提。

12、Overload和Override的区别

override可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点：

1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；

2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；

3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；

4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

overload可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点：

1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int,float)，但是不能为fun(int,int)）；

2、不能通过访问权限、返回类型、抛出的异常进行重载；

3、方法的异常类型和数目不会对重载造成影响；

4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。

13、final关键字

final可以修饰类，方法，变量。

final修饰的类不可以被继承。

final修饰的方法不可以被覆盖。

final修饰的变量是一个常量。只能被赋值一次。

内部类只能访问被final修饰的局部变量。

14、使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？

使用final关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。例如，对于如下语句：

 final StringBuffer a=new StringBuffer("immutable");

执行如下语句将报告编译期错误：

a=new StringBuffer("");

但是，执行如下语句则可以通过编译：

a.append(" broken!"); 

 

有人在定义方法的参数时，可能想采用如下形式来阻止方法内部修改传进来的参数对象：

publicvoid method(final  StringBuffer  param)

{

}

实际上，这是办不到的，在该方法内部仍然可以增加如下代码来修改参数对象：

          param.append("a");

15、抽象类概述

1抽象定义：

抽象就是从多个事物中将共性的，本质的内容抽取出来。

例如：狼和狗共性都是犬科，犬科就是抽象出来的概念。

抽象类：

Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，

包含抽象方法的类就是抽象类。

抽象方法的由来：

多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，

并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。

例如：狼和狗都有吼叫的方法，可是吼叫内容是不一样的。所以抽象出来的犬科虽然有吼叫功能，

但是并不明确吼叫的细节。

 抽象类的特点

抽象类和抽象方法必须用abstract关键字来修饰。

抽象方法只有方法声明，没有方法体，定义在抽象类中。

格式：修饰符abstract返回值类型函数名(参数列表);

抽象类不可以被实例化，也就是不可以用new创建对象。原因如下：

抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例。

例如：犬科是一个抽象的概念，真正存在的是狼和狗。

而且抽象类即使创建了对象，调用抽象方法也没有意义。

抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，

否则该子类也是抽象类。

 

public abstract class Employee {
public abstract void setName(String name);

public abstract String getName();

public abstract void setSex(char sex);

public abstract char getSex();

public abstract void setAge(int age);

public abstract int getAge();

public abstract void setJob(String job);

public abstract String getJob();
}

public class User extends Employee {
private String name;
private String job;
private char sex;
private int age;
public String like; // 爱好

public void worker() {
System.out.println(this.name + "工作中");
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getJob() {
return job;
}

public void setJob(String job) {
this.job = job;
}

public char getSex() {
return sex;
}

public void setSex(char sex) {
this.sex = sex;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getLike() {
return like;
}

public void setLike(String like) {
this.like = like;
}

}

public class Company {
public String companyName;// 公司名称
public String companyAdress;// 公司地址
public String companyBoss;// 公司老总
public List<Employee> employees;// 公司员工
}

16、接口

格式：publicinterface接口名称{}

接口中的成员修饰符是固定的。

成员常量：publicstaticfinal

成员函数：publicabstract

发现接口中的成员都是public的。

接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。

接口与抽象的区别于共性和区别：

共性：都是不断抽取出来的抽象的概念

区别：

（1）抽象类体现继承关系，一个类只能单继承接口体现实现关系，一个类可以多实现

（2）抽象类是继承，是"isa"关系。接口是实现，是"likea"关系

（3）抽象类中可以定义非抽象方法，供子类直接使用

接口的方法都是抽象，接口中的成员都有固定修饰符

17、多态

定义：某一类事物的多种存在形态。

例：动物中cat，dog。

cat这个对象对应的类型是cat类型

catx=newcat();

同时cat也是动物中的一种，也可以把cat称为动物。

动物y=newcat();

动物是猫和狗具体事物中抽取出来的父类型。

父类型引用指向了子类对象。

程序中体现：

父类或者接口的引用指向或者接收自己的子类对象。

class Animal {
}

class Cat extends Animal {
public static void main(String[] args) {
Animal a = new Cat();// 这个就是多态的实现
}
}

好处和作用：

多态的存在提高了程序的扩展性和后期可维护性

前提：

1)需要存在继承或者实现关系

2)要有覆盖操作

多态的特点

成员函数：

编译时：要查看引用变量所属的类中是否有所调用的成员。

在运行时：要查看对象所属的类中是否有所调用的成员。

成员变量：

只看引用变量所属的类。

class Animal {
}

class Cat extends Animal {
public static void main(String[] args) {
Animal a = new Cat();// 这个就是多态的实现
}
}

18、作用域public，private，protected，以及不写时的区别

这四个作用域的可见范围如下表所示。
说明：如果在修饰的元素上面没有写任何访问修饰符，则表示friendly。
作用域    当前类  同一package  子孙类  其他package
public     √        √         √           √
protected  √        √         √           ×
friendly   √        √         ×           ×
private    √        ×         ×           ×