Java基础与面向对象思想

Java程序规范：
1、Java语言拼写上大小写敏感，Hello和hello是两个不同的类名。
2、一个源文件可以定义多个Java类，但最多只能有一个类定义成public类。
3、如果源文件中包含了public类，则源文件必须和该public类同名。
4、一个源文件包含多个Java类时，编译后会多成多个字节码文件，即每个类会生成一个单独“.class”文件，且其文件名与类名相同。

Java类的组成结构：
1、成员变量：描述事物的状态参数
2、成员方法：描述事物的行为/功能。
3、构造方法：创建一个新对象，同时返回其在内存中的地址。

Java类中定义的构造方法定义规则：
1、构造方法必须和所在类同名。
2、构造方法声明时不允许指定返回值类型。
3、如果一个类中没有显示定义构造方法，则系统会自动为该类提供一个缺省的构造方法，缺省构造方法无参数同时方法体为空。
4、如果一个类中显示定义了构造方法，系统将不再提供缺省的构造方法。

Java对象的创建：
1、Java中采用new关键字调用类中定义的构造方法来创建对象。
2、通过对象名.属性名或对象名.方法名来访问对象的属性或方法。
3、一个对象不能访问同类型的其他对象的成员或方法。

Java的封装性：
在定义Java类时，将属性声明为私有类型（private），以限制外界对属性的直接访问，同时提供对该属性进行存取操作的公开方法（public）的方法，并在方法中加入必要的检查

或控制逻辑。

Java的3种注释方式：
1、//注释内容从//开始，到本行行尾结束
2、/*  */ 以/*开始，到*/结束，可以跨行
3、/** */ 以/**开始，到*/结束，可使用JDK提供的文档化工具javadoc将注释内容提取出来生成软件说明文档。

Java整型数据类型：
byte 1字节（8位）、short 2字节（16位）、int 4字节（32位）、long 8字节（64位）
Java中表示整型数据的方式：十进制（10）、十六进制（Ox10）、八进制（010）对应的十进制为：10、16、8

Java中的变量：需要事先声明，还必须被初始化，赋过值后才可以使用。

Java中引用类型变量初始化过程：
1、为新建对象分配存储空间并进行默认初始化
2、对新建对象进行显示初始化
3、执行构造方法体中的语句
4、每个新建对象被系统分配一个唯一标识一个对象的hashCode码，称为对象的“句柄”。
5、声明一个变量来保存新建对象的“句柄”。

Java中成员变量如果不显示赋值，会默认进行初始化，局部变量必须进行初始化，否则编译出错。

Java虚拟机中的堆内存与栈内存的区别：
1、堆内存：由所有的应用程序公用，存储空间分配不连续，存储内容大，访问速度慢。
2、栈内存：由特定应用程序专用，存储空连续，以栈的方式管理内存，存储容量小，访问速度快。
3、局部变量保存在栈内存中，对象及成员变量保存在椎内存中。

Java语言的传递参数是遵循值传递原则：基本类型传递值的本身，引用类型传递对象的引用（句柄）

this关键字用法：
1、在成员方法中：关键字this代表方法的调用者，即本次调用该方法的对象。
2、要构造方法中：关键字this代表了该方法本次运行所创建的那个新对象。
3、Java方法通过直接给出“变量名”时，会将其当做局部变量来处理，如果局部变量不存在，则到成员变量中去查找，如果成员变量中也没有，则编译出错。

Java编码规范：
1、类名或接口名：名词或名词性词组，每个单词首字母大写
2、方法名：动词或动词性词组，首字母小写，每二个及以后的单词首字母大写
3、变量名：名词或名词性词组，首字母小写，每二个及以后的单词首字母大写
4、常量：名词或名词性词组，每个单词的字母全大写，单词间用“_”分隔。
5、包：名词或名词性词组，全部小写，一般是公司网站域名的逆序

Java源文件的组织结构：
1、开始的注释
2、package语句
3、import语句
4、类/接口声明

Java类的组成排列顺序:
1、属性声明
2、构造方法声明
3、语句块
4、static语句
5、普通方法声明
6、main方法声明
7、内部类声明

Java取余运算符的结果将保持和被除数相同的符号。

Java逻辑运算符中：“&&短路与” 、“||短路或” 和 “&”、“|”区别
当其根据第一个数的值已经能够确定整个表达式的结果时，将跳过对第二个操作数的计算，直接给出最终结果。

定点二进制数的表示方式：
1、原码：最高位为符号位，0表示正数，1表示负数，其余位数表示数值（绝对值）的大小。
+9 00000000 00000000 00000000 00001001
-9 10000000 00000000 00000000 00001001
+0 00000000 00000000 00000000 00000000
-0 10000000 00000000 00000000 00000000
2、反码：正数的反码与原码相同，负数的反码是符号位不变，对其绝对值的原码逐位取反。
+9 00000000 00000000 00000000 00001001
-9 11111111 11111111 11111111 11110110
+0 00000000 00000000 00000000 00000000
-0 11111111 11111111 11111111 11111111
3、补码：正数的补码与原码相同，负娄的补码是符号位不变，对其绝对值的原码逐位取反后再在末位加1（反码+1）。
+9 00000000 00000000 00000000 00001001
-9 11111111 11111111 11111111 11110111
+0 00000000 00000000 00000000 00000000
-0 00000000 00000000 00000000 00000000
补码与原码之转换：
第1种：
补码：-9 11111111 11111111 11111111 11110111
反码：-9 11111111 11111111 11111111 11110110 -1取得反码
原码：-9 10000000 00000000 00000000 00001001   -符号位不变，各位取反得到原码
第2种：
补码：-9 11111111 11111111 11111111 11110111
取反：   10000000 00000000 00000000 00001000   符号位不变，各位取反
原码：-9 10000000 00000000 00000000 00001001  末位加1，得到原码
Java语言中二进制形式的整数采用补码形式的二进制表示。

Java中移位运算：
a<<b左移：将整数a的二进制方式左移b位，右侧低位补0，高位b位丢弃。
a>>b带符号右移：将整数a的二进制形式右移b位，左侧最高位补符号位，右侧低位被丢弃。
a>>>b无符号右移：将整数a的二进制形式右移b位，左侧最高位补0，右侧低位被丢弃。
移位运算的移位位数不一定是b位，当a为int型（byte、short、char）型时，系统会先将b对32取模，得到的结果才是真正的位数，当a为long类型时，系统先将b对64进行取模，得

到
的结果才是真正的移位位数。

Java中的自增++和自减--的使用：
用来对单位变量自身加1或减1的操作，在复合表达式中：
++i、--i先进行变量的自增1或自减1后，再参与运算。
i++、i--先参与运算，再进行变量的自增或自减操作。

Java中运算符的优先级：
[] () . (方法调用)  ->  ++ -- + - ~ ! (强制类型转换) new  -> * / %  ->
+(加) -(减)  ->  << >> >>>  ->  < <= > >= instanceof  ->
== !=   ->  &   ->  ^  ->  |  ->   &&  ->  ||  ->  ?:  ->

赋值表达式：有自己的值和数据类型，赋值后等号左侧变量的值就是整个表达式的值，该变量的数据类型就是整个表达式的类型。如果表达式没有返回类型，则认为是void类型。

Java中的数据类型转换：
byte->short/char->int->float<->long->double
      
Java数据自动类型转换规则：
1、如果两个操作数中有一个是double型，则系统先将另一个操作数的值转换为double类型，然后进行运算，否则，
2、如果两个操作数中有一个是float型，则系统先将另一个操作数的值转换为float类型，然后进行运算，否则，
3、如果两个操作数中有一个是long类型，则系统先将另一个操作数的值转换为long类型，然后进行运算，否则，
4、两个操作数的值都将转换为int型。
5、如果只有一个操作数，且其类型低于int型时，则将该操作数的值转换为int型。

强制类型转换：
Java语法中规定，可以将int型数值常量直接赋值给相对低级的byte、short或char型变量，如果不超出变量的表数范围，而不需要进行强制类型转换。

Java语法中的switch后面的常量表达式只能是：byte、short、char、int类型，或是引用类型中的枚举或是四种基本类型的封装类。

Java循环结构中的while 和do while区别：
当do while循环条件表达式的值一开始就不成立时，其循环体语句仍至少执行一次。

Java中的数组属于引用类型，直接继承了Object类，数组元素必须为同一种类型，下标从0开始，声明数组变量时不允许指定长度，Java数组对象一经创建，长度不能改变。通过数

组名.length可以取得定义的数组的长度。

通过使用System.arraycopy()方法完成数组拷贝时，拷贝的是原数组中指定元素中保存的值，在多维数组拷贝时，只拷贝最高维元素的值，即低维数组对象的句柄。

Java API常用包说明：
java.lang Java中的基础类
java.awt 处理图形用户界面类
java.util 集合、日期、格式化类
java.io 输入/输出相关功能的类
java.net Java中的网络编程类
java.sql 操作数据库相关功能类

使用用户自定义包中的类，有时会出现“import <包名>.*”不能正常引入的情况，为JDK版本中的一个BUG，改成“import <包名>.类名”方式引入。

继承：
1、当一个类继承了另一个类，则这个类将继承其父类的所有属性和方法。
2、当一个类如果没有显示指定继承任何父类，那么将自动继承Object类（位于java.lang包中）。
3、Java语言只支持单重继承，即一个Java类只能有一个直接父类。

Java中类之间的关系（3种）：
1、依赖关系：指一个类的方法中使用到了另一个类的对象。
2、关联关系：指一个类的对象包含了另一个类的对象。
3、泛化关系：表示类之间的继承关系。
4、实现关系：表示一个类实现了一个接口。

访问控制：
public：修饰的成员可以在任何范围内直接访问，所访直接访问需先创建或获得一个相应类的对象，然后使用“对象名.成员”方式访问。
protected：修饰的成员可以在其所在类中，同一包中，子类中被直接访问，但不能被位于不同包的非子类中直接访问，在位于不同包的子类中，必须是子类的对象才可以直接访问

其父类的protected成员，而父类自身的对象反而不能访问其所在类中声明的protected成员。
无修饰符：缺省访问控制修饰符只能在其所在类中、或同一个包中被直接访问，在不同包中，即使是不同包中的子类中也不能直接访问。
private：修饰的成员只能在其所在类中被直接访问。

方法重写：在继承关系中，子类中定义和父类中同包的方法，称为子类重写了父类的方法。
方法重写遵守的三个原则：
1、重写方法必须和被重写方法具有相同的方法名称，参数列表（形参的数目、类型、和顺序，不包括参数名称）、和返回值类型。
2、重写方法不能使用比被重写更严格的访问权限。
3、重写方法不允许声明抛出比被重写方法范围更大的异常类型。
4、重写方法时允许修改其返回类型，必须是重写前的方法的返回值类型的子类或实现类的类型

父类与子类之间存在同名属性时：
1、以“对象名.属性名”方式直接访问时，使用的是自己类中添加的属性。
2、调用子类添加或重写的方法时，方法中使用的是子类定义的属性。
3、调用父类中定义的方法时，方法中使用的是父类中的属性。

关键字super的使用：
1、访问父类中定义的属性：super.<属性名>
2、调用父类中定义的成员方法：super.<方法名>(<实参列表>)
3、在子类构造方法中调用父类的构造方法：super(<实参列表>)

多态：子类的对象替代父类的对象使用。

Java引用类型变量与其所引用对象的类型匹配关系：
1、一个对象保能属于一种确定的数据类型，该类型自对象创建到消毁，不能改变。
2、一个引用类型变量可能引用多种不同类型的对象，既可以引用其声明类型的对象，也可以引用其声明类型的子类的对象。
3、如果一个引用类型变量声明为父类的类型，但引用的是子类对象，则该变量不能再访问子类中添加的属性和方法，但去可以访问低父类中声明过、被子类重写过的方法。
4、编译器会根据变量声明的类型进行检查，变量需要事先声明，且被初始化过，访问的是在变量声明的类型或或父类中定义过，且访问控制权限允许直接访问的成员，这样编译器

才会通过编译（匿名对象除外）。
5、当变量做为形参时，不用显式进行赋值，即可以直接使用，在方法调用时，由系统自动将实参值赋给形参。

对象造型：
1、从子类到父类的类型转换可以自动进行。
2、从父类到子类的类型转换，需要强制类型转换(子类名)父类对象。
3、无继承关系的引用类型间

instanceof运算符：判断一个对象是否属于某种类型，格式：对象名 instanceof 类名

协变返回类型：允许重写方法时修改其返回类型，必须是重写前的方法的返回值类型的子类或实现类的类型。

方法重载：指一个类中的方法名相同，方法的参数列表不同，则称为方法重载。
方法重载的满足条件：
1、方法名相同
2、方法的参数类型、个数、顺序至少有一项不同
3、方法的返回值类型可以不相同
4、方法的修饰符可以不相同

方法重写和方法重载的区别：
相同点：
1、都要求方法同名
2、都可以用于抽象方法和非抽象方法之间
不同点：
1、方法重写要求参数列表必须一致，而方法重载要求参数列表不一致
2、方法重写要求返回值类型可以是重写前的方法的返回值类型的子类或实现类的类型，方法重载不要求返回值类型
3、方法重写只能用于子类重写父类的方法，方法重载用于同一个类的所有方法（包括从父类继承下来的方法）
4、方法与对方法的访问权限和抛出的异常有特殊的要求，而方法重载在这方面没有限制
5、父类的一个方法只能被子类重写一次，而一个方法在所在的类中可以被重载多次

static关键字的使用：
1、用static修饰的成员变量表示静态变量，可以直接通过类名来访问，归类所有。
2、用static修饰的成员方法表示静态方法，可以直接通过类名来访问，归类所有。
3、用static修饰的程序代码块表示静态块，当Java虚拟机加载类时，会执该代码块。
4、在静态方法中，不能使用this和super关键字。
5、静态变量只在类加载时执行一次，为整个类所共享。
6、static关键字不能和abstract一起使用。

静态变量、成员变量、静态方法、成员方法的访问原则：
1、静态变量：静态变量、静态方法
2、静态方法：静态变量、静态方法
3、成员变量：静态变量、成员变量、静态方法、成员方法
4、成员方法：静态变量、成员变量、静态方法、成员方法

加载一个类的四种方式：
1、采用new运算符创建一个对象时
2、通过类名调用静态成员时
3、通过反射机制：Class.forName()动态加载一个类
4、通过类加载器：ClassLoader.getSystemClassLoader().loadClass();//不初始化静态成员的值。

final关键字的使用：
1、用final修饰的类不能被继承
2、用final修饰的方汉不能被子类的方法重写
3、用final修饰的变量表示常量，只能被赋值一次，不能修改
4、final不能和abstract一起使用
5、final修饰的变量可以是成员变量、静态变量、和局部变量

abstract关键字的使用：
1、abstract修饰的类为抽象类
2、abstract修饰的方法为抽象方法
3、abstract不以和final或static一起使用
4、abstract不能修饰构造方法

抽象类：
1、抽象类不能被实例化
2、抽象类中可以没有抽象方法，但是包含了抽象方法的类必须定义为抽象类
3、如果子类没有实现父类中所有的抽象方法，子类也必须定义为抽象类
4、抽象类不能被定义为final和static类型
5、抽象类可以包含构造方法，但是没有抽象构造方法

抽象方法：
1、抽象方法只包含方法的定义，没有方法体
2、每一个抽象方法定义结束后加分号结束
3、在定义抽象方法时，不能和private、static、final一起使用

接口
1、接口中的成员变量默认类型为public static final类型，必须显示初始化
2、接口中的方法默认类型为public abstract类型的
3、接口中只能包含public static final类型的成员变量和public abstract类型的成员方法
4、接口中没有构造方法，不能被实例化
5、一个接口不能实现另一个接口，但可以继承多个其他接口
6、接口必须通过类来实现它的抽象方法
7、如果一个类实现一个接口，那么必须实现接口中定义的全部抽象方法，否则需要将其定义为抽象类
8、不允许创建接口的对象，但接口支持多态性
9、一个类只能有一个直接父类，但去可以实现多个接口

抽象类和接口的区别：
1、什么是抽象类：在一个类的修饰符前加上关键字abstract，抽象类中可以包含0或多个抽象方法，可以定义自己的构造方法，可以有自己的成员变量，可以包含实现的成员方法

。
2、什么是接口：通过interface关键字来定义，在一个接口中定义的全部成员变量为常量，由接口本身所拥有，类型为public static final，接口中定义的方法为抽象方法，没有

方法体。
3、一个类只能继承一个抽象类，却可以实现多个接口
4、如果一个类中有一个方法为抽象方法，则这个类必须定义成抽象类。
5、接口之间可以多重继承。