面向对象的相关知识点（笔试题可能会考到）

1、类的创建，修饰符；属性的定义；方法的声明

类：一类事物的描述，抽象概念上的定义

类的语法格式：

修饰符（public，default） class 类名{

                   成员变量；

                   方法

}

类的属性有默认值，数值是0，boolean是false，引用是null

取名要“见名知意”

类名的首字母大写

变量名和方法的首字母小写

采用驼峰命名法

类设计技巧：

让成员变量(属性)私有(用private修饰)

公开方法(用public修饰)

属性是所定义类中的所有成员变量；

方法的定义格式：

public static 返回值类型 方法名称（类型 参数1，类型 参数2…）{

         方法的主体

         程序语句：

         [return表达式]；

}

 

2、构造方法

构造方法：类有一默认无参数的构造方法，如果定义有参数的构造方法，无参数的将失效。

功能：实例化对象并初始化

格式：无返回值类型，无void修饰，参数通常对应属性（成员变量）

public 类名（参数）{

}

3、方法的重载，重写（普通方法，构造方法）

方法重载：在一个类中，方法名相同。参数不同的多个方法，与返回值无关

参数不同：类型不同，顺序不同，个数不同

构造方法也可重载

 

方法重写：子类继承父类，在子类中重写编写父类中的某个方法

重写的要求：返回值类型，方法名，参数列表必须相同，权限不能更严格，建议去copy父类的方法

4、实例化对象，父类引用指向子类对象

类：是一类事物的描述，抽象概念上的定义。概念，定义，模板：车，水杯，人

对象：具体的事物，该类事物的具体的一个对象，也称为实例，宝马X5，喜乐，张三

类，class

对象，object

实例，instance

抽象：对象--》类

实例化：类--》对象

5、类的继承

两个类存在继承关系

继承关键字：子类 extends 父类

java只支持单继承，意味着extends后只能一个父类

 

类的属性和方法可以被继承，而构造方法不能被继承

对于父类中私有的成员变量，子类有使用权，没有所有权

6、Object

Object是所有类的基类，这个你可以查询jdk文档了解，所有类都继承自Object。

Object ...objects这种参数定义是在不确定方法参数的情况下的一种多态表现形式。即这个方法可以传递多个参数，这个参数的个数是不确定的。这样你在方法体中需要相应的做些处理。因为Object是基类，所以使用Object ...objects这样的参数形式，允许一切继承自Object的对象作为参数。这种方法在实际中应该还是比较少用的。

Object[] obj这样的形式，就是一个Object数组构成的参数形式。说明这个方法的参数是固定的，是一个Object数组，至于这个数组中存储的元素，可以是继承自Object的所有类的对象。

 

7、抽象类，接口

抽象类：

抽象类不能实例化对象，只能被继承，重写抽象方法

 

如果子类继承抽象类，不重写抽象类中的方法，子类中的该方法，需声明为抽象的，同时该类也需声明为抽象的

 

抽象类中可以有普通方法

 

抽象类不一定有抽象方法；有抽象方法的类必须是抽象类

 

抽象类可以作为变量的类型

接口，interface，是抽象方法和常量值的定义的集合

 

a:接口定义格式

public interface 接口名{

   抽象方法；

   常量；

}

抽象方法使用public abstract修饰，常量使用public static final修饰，修饰符始终不改变，所以说，修饰符可以省略

 

b:实现接口，类implements 接口1，接口2……

 

类与类之间是继承关系，单继承

类与接口之间是实现关系，可以多实现

接口与接口之间是继承关系，可以多继承

8、面向对象特点：继承，封装，多态

抽象：将一类事物共同的特征抽取出来，包括属性和行为（方法），定义成类

封装：将一类事物的属性和方法包装起来形成类

多态：多种形态

静态多态，编译时的多态：方法重载

动态多态，运行时的多态：继承，重写，父类引用指向子类对象

 

多态的两种体现

重载：同一个类中，方法名相同，参数不同（个数，顺序，类型）的多个方法

重写：子类继承父类，重写编写父类的方法，要求，返回值类型，方法名，参数列表相同，权限不能更严格

 

对象的多态性：

向上转型：父类引用指向子类对象，不能访问子类新增的成员

向下转型：强转，使用instanceof判断，引用类型的变量是否该类或其子类所实例化

9、多态

多态：多种形态

静态多态，编译时的多态：方法重载

动态多态，运行时的多态：继承，重写，父类引用指向子类对象

 

多态的两种体现

重载：同一个类中，方法名相同，参数不同（个数，顺序，类型）的多个方法

重写：子类继承父类，重写编写父类的方法，要求，返回值类型，方法名，参数列表相同，权限不能更严格

 

对象的多态性：

向上转型：父类引用指向子类对象，不能访问子类新增的成员

向下转型：强转，使用instanceof判断，引用类型的变量是否该类或其子类所实例化

10、数组，排序、查找

数组，array

1、数组：[],[][]

a:数组存储相同类型的数据（基本，引用）

b:数组变量是引用类型，数组都是new出来的

c:数组的每个元素都有索引（下标，范围，0~n-1，n为数组的长度），通过索引可以访问数组元素的值

d:数组创建之后，长度不可改变，但是元素值可以改变

 

2、一维数组的创建：

声明格式：数组在声明时不需指定数组的大小

数据类型[] 数组变量名 或者数据类型 数组变量名[]

int[] a; 或者 int a[];

Student[] s ;  Student s[];

 

创建格式：创建数组，给数组分配连续的存储空间,数组有初始值，数值类型0，boolean，false，引用类型，null

 

声明和创建：

数据类型[] 数组变量名 = new 数据类型[数组长度];

int[] a = new int[10];

 

数组的访问：

格式：

数组变量名[下标];，如果超出最大下标值：报异常，数组下标越界java.lang.ArrayIndexOutOfBoundsException

 

获得数组的长度，数组名.length;

 

3、数组的初始化

静态初始化：

数据类型[] 数组变量名={相应数据类型的值，多个值“，”隔开}；

数组的长度根据元素个数来决定

int[] a ={1,2,3,4,5};

String[] s ={"ab","cd","ef"};

int[] b = new int[]{1,23,3};

 

动态初始化：数组的创建和初始化分开

int[] a = new int[10];

 

String[] s ;

s = new String[3];

s[0]="afd";

 

4、增强for循环，也称为foreach

格式：遍历

for(数据类型 变量名:数组名)

变量名：代表数组或集合中的一个元素

 

缺陷：无法通过下标访问数组元素

通常在遍历数组或集合时使用

 

5、可变参数：当定义方法时，传入方法的参数个数不固定

格式：

形参：数据类型... 变量名

 

二维数组：数组的数组，[][]

动态初始化

int[][] a = new int[5][4];

 

int[][] b = new int[2][];

//b[0]= new int[3];

//b[1]= new int[4];

b[0]=new int[]{1,1,2,3};

b[1]=new int[]{12,3};

 

静态初始化

int[][] c = {{1,2,3},{1,1},{2,2}};

 

遍历二维数组

for (int i = 0; i < a.length; i++) {

   for(int j = 0; j < a[i].length; j++) {

      System.out.print(a[i][j]+ " ");

   }

   System.out.println();

}

 

7、排序：按大小个战队，从大到小

冒泡：

a:确定比较多少轮，n个数需要比较n-1轮

b:两个相邻的数进行比较，a[j],a[j+1]

c:每轮比较确定一个最大值，该最大值是未排序区中最大，将该值放到为排序区的最后

插入排序：

思想：将未排序区的第一个元素，插入到已排序区

a:n个数比较，需要n-1轮

选择排序：

思想：每一轮比较，从未排序区中选择相对最小的元素，放在已排序区的最后，直到全部排序完毕

a:n个数比较，需要n-1轮

查找：

顺序：

二分查找：

a:已排序的数组

b:二分查找的基本思想是:

首先确定该查找区间的中间点位置： intmid = (low+upper) / 2;

然后将待查找的值与中间点位置的值比较：

   若相等，则查找成功并返回此位置。

   若中间点位置值大于待查值，则新的查找区间是中间点位置的左边区域。

   若中间点位置值小于待查值，则新的查找区间是中间点位置的右边区域。下一次查找是针新的查找区间进行的。

11、异常，五个关键字

异常，exception：运行期出现的不正常事件，出现异常程序中断

 

设计良好的应用程序，应该在异常出现的位置进行捕获并处理

 

1、异常的分类：

Throwable：错误和异常的根类，直接子类，Error（错误），Exception（异常）

Error：编写程序不能进行处理，比如内存异常，jvm出现错误

Exception：可以编写代码捕获并处理的不正常事件

一般性异常，受检异常：需要捕获处理

运行时异常，非受检异常：可以不进行处理

 

1、try{}：有可能出现异常的代码，只能有一个

catch（Exceptione）{}：捕获异常，并处理，e封装了异常的相关信息，catch可以有多个

e.printStackTrace();

 

try代码块如果出现异常，被catch代码块捕获并处理，之后程序继续向下执行

如果不出现异常，try语句块执行完毕，继续向下执行

 

多个catch语句块，如果异常之间存在继承关系，父类放后边，子类放前边

如果没有关系，catch语句块随意

 

finally：无论是否出现异常，该语句块都会执行，释放资源，关闭流，关闭数据连接

 

上述三个关键字：

try，catch

try，catch，finally

try，finally

 

2，throws：在方法声明时，方法体中，如果出现异常，并未处理，使用该关键字将异常抛出，在调用处进行处理。

可以抛出多个异常，逗号隔开，如：

public void fun() throwsFileNotFoundException,IOException{

 

throw：抛出异常，后加异常类对象，通常使用在自定义异常

12、参数传递，基本，引用

方法的参数传递：实参给形参传值

方法的参数，声明方法时，参数叫形参；调用方法时，参数叫实参

 

传值有两种方式：

a:基本类型，传递值本身

b:引用类型，传递地址

13、基本类型的包装类

基本类型的包装类：java.lang

byte -->Byte

short-->Short

int-->Integer:valueOf,parseInt("")

long-->Long

float-->Float

double-->Double

char-->Character:isDigit,isLetter,isLowerCase,isUpperCase

boolean -->Boolean

自动装箱，拆箱

装箱：基本类型--》包装类对象

拆箱：包装类对象--》基本类型

14、字符串、calendar

Java中对日期的处理需要用到Calendar类，其中有几个方法在使用时需要新手注意。

1. 在获取月份时，Calendar.MONTH + 1 的原因
Java中的月份遵循了罗马历中的规则：当时一年中的月份数量是不固定的，第一个月是JANUARY。而Java中Calendar.MONTH返回的数值其实是当前月距离第一个月有多少个月份的数值，JANUARY在Java中返回“0”，所以我们需要+1。

2. 在获取星期几 Calendar.DAY_OF_WEEK – 1 的原因
Java中Calendar.DAY_OF_WEEK其实表示：一周中的第几天，所以他会受到 第一天是星期几的影响。
有些地区以星期日作为一周的第一天，而有些地区以星期一作为一周的第一天，这2种情况是需要区分的。
看下表的返回值

星期日为一周的第一天 SUN MON TUE WED THU FRI SAT 
DAY_OF_WEEK返回值 1 2 3 4 5 6 7 
星期一为一周的第一天 MON TUE WED THU FRI SAT SUN 
DAY_OF_WEEK返回值 1 2 3 4 5 6 7 

所以Calendar.DAY_OF_WEEK需要根据本地化设置的不同而确定是否需要 “-1”
Java中设置不同地区的输出可以使用 Locale.setDefault(Locale.地区名) 来实现。

3. 获取日期时 Calendar.DAY_OF_MONTH 不需要特殊的操作，他直接返回一个月中的第几天

15、集合

集合类:存储多个对象

16、内部类

内部类：在类的内部，方法内部定义的类

内部类：inner class

外部类：outer class

 

成员内部类：可以直接访问外部类的私有成员变量

a:也叫实例内部类

b:成员内部类中不能定义静态变量，除非定义为静态常量，例如private final static int age=20;

c:成员内部类持有外部类的引用，可以访问外部类的成员变量和方法

 

字节码文件：Outer$Inner.class

实例化内部类对象：Outer.Innerinner =new Outer().new Inner();

 

静态内部类，使用static 修饰内部类

静态内部类不持有外部类的引用，创建时不用实例化外部类对象，直接外部类点内部类

静态内部类中可以直接访问外部类的静态成员，如果访问外部类的非静态成员可以通过实例化外部类对象来访问

字节码文件：Outer$Inner.class

实例化内部类对象：Outer.Innerinner = new Outer.Inner();

 

局部内部类：定义在方法内部，与成员内部类类似，

作用域为该方法，使用时在方法内实例化对象调用方法，如：new Inner().print();

 

如果外部类的方法有参数，必须声明为final，延长变量的生命周期

因为加final修饰，该常量存在常量池中

字节码文件：Outer$1Inner.class

 

匿名内部类，没有类名，该功能只用一次

创建：new 类或接口（）{重写方法}；

字节码文件：C$1.class

17、list，set、map

List：存放的元素是有顺序可以重复

Set：存放的元素无序不重复

Map：存储键值对

18、重写，重载

方法重载：在一个类中，方法名相同。参数不同的多个方法，与返回值无关

参数不同：类型不同，顺序不同，个数不同

构造方法也可重载

 

方法重写：子类继承父类，在子类中重写编写父类中的某个方法

重写的要求：返回值类型，方法名，参数列表必须相同，权限不能更严格，建议去copy父类的方法

19、this、super

this关键字：

用法一：代表自身的引用

a:用在普通方法中，比如setter和getter方法，this代表调用该方法的对象的引用，谁调用该方法就代表谁

b:用在构造方法中，this代表实例化的对象

用法二：调用本类中其他的构造方法，格式，this(参数列表);

使用在构造方法中，并且放在第一行

super：父类的引用

a:使用super（参数列表）；调用父类中的构造方法，必须放在子类构造方法的第一条语句

this（参数列表）；调用本类中其他的构造方法

b:可以访问父类的成员，包括成员变量（非私有）和方法

c:this和super不能使用在静态方法中

this和super的区别

a:访问非私有的属性和方法：

this，首先在子类中查找，如果没有，查找父类

super，访问父类的成员

 

b:调用构造方法：

this：调用本类中其他的构造方法

super：调用父类中的构造方法

 

c:this，代表自身的引用

super，代表父类的应用

 

d:this和super不能使用在静态方法中

20、extends，implements

继承：子类 extends 父类，java支持单继承

实现接口，类 implements 接口1，接口2……

5、关键字：static、final，abstract

static关键字：静态的，可以修饰成员变量和方法

a:静态成员变量：所有对象共用一份，所有对象共同使用同一个静态成员变量，并不属于某一个对象，而是属于类，所以也可以称为类变量

 

实例化对象时，普通成员变量，每个对象都有自己的一份。

 

静态成员变量，如果不是private修饰，可以使用类名或对象名去访问

 

b:静态方法：属于类，也可以称为类方法，可以使用类名或对象名去访问

静态方法只能访问静态的成员，包括静态成员变量和静态方法

静态方法中不能使用this和super关键字

 

类加载时先加载静态的成员变量和方法

 

final，最终的，可以修饰变量，方法，类

修饰变量（局部变量，成员变量），值不可改变，即为常量，变量名通常为大写

修饰方法：不能被重写

修饰类：不能被继承

 

abstract：抽象的，抽象类，抽象方法，

 

a:抽象类：

抽象类不能实例化对象，只能被继承，重写抽象方法

 

如果子类继承抽象类，不重写抽象类中的方法，子类中的该方法，需声明为抽象的，同时该类也需声明为抽象的

 

抽象类中可以有普通方法

 

抽象类不一定有抽象方法；有抽象方法的类必须是抽象类

 

抽象类可以作为变量的类型

 

b:抽象方法：无方法体，即无{}

构造方法、静态方法、私有方法、final方法不能被声明为抽象的方法