面向对象常见问题总结

构造方法的特点: 方法和类名相同,返回值类型无用,不能重载 抽象类和抽象方法的特点是什么: 1 通过abstract关键字调用 2 不能实例化。 3 抽象方法

构造方法的特点:

方法和类名相同,返回值类型无用,不能重载

抽象类和抽象方法的特点是什么:

1.通过abstract关键字调用

2.不能实例化。

3.抽象方法中不能写方法体,只能方法声明。

方法重载和方法重写区别:

方法重载:方法名相同、参数列表不同和返回值类型无关。

方法重写:与父类方法名、返回值类型、参数列表相同,子类访问修饰符不能比父类比父类低。

继承有什么特点?继承的优点是什么?

特点:在Java中,只支持单继承,不支持多继承。

           在Java中,所有的Java类都继承Object类。

优点:提高了代码的复用性。

           提高了代码维护性。

多态的特点?有什么优点?

特点:1.要有继承关系或实现关系(接口)。
      2.要有方法重写。
      3.要有父类或者父接口引用指向子类。(形参父类实参子类)

优点:1.可替换性。

           2.可扩容性。

           3.接口性

           4.简化性

多态的实现方式是什么:

1.接口

2.重写

3.抽象类和抽象方法

如何编写接口:

使用关键字Interface

public interface Seed{
     public void freed();    //public 可写可不写
}

class Tests implements{
       public void freed(){}
}

 

接口的作用是什么:

1.规范代码格式

2.便于维护人员维护

3.保证代码安全性和严密

接口和抽象类有什么异同:

相同:都不能被实例化,只有实现了接口或者抽象类中的方法后才能被实例化。

不同点:接口只有定义,不能在接口中实现。抽象类可以有定义与实现,可以在抽象类中被实现。

什么是异常,如何理解?

异常是指在程序的运行过程中所发生的不正常的事件,它会中断运行的程序。

如何处理异常,异常的关键字是什么

try、catch、finally、throwthrows

常见的异常种类有哪些:

Exception    异常层次结构的父类

ArithmeticException   算术错误情形,如以零作除数

ArraylndexOutOfBoundsException   数组下标越界

NullPointerException   尝试访问 null 对象成员

ClassNotFoundException   不能加载所需的类

IllegalArgumentException    方法接收到非法参数

NumberFormatException   数字格式转换异常

ClassCastException     对象强制类型转换出错

如何使用log4j记录日志

 

常见的集合有哪些?他们有什么常用方法?

List、Set和Map

Collection常用方法:

boolean add(Object o)
/**在列表的末尾顺序添加元素,
*起始索引位置从0开始
*/
void add(int index,Object o)
/**在指定的索引位置添加元素。
*索引位置必须介于0和列表中元素个数之间
*/
int size()
//返回列表中的元素个数
Object get(int index)
//返回指定索引位置处的元素
boolean contion(Object o)
//判断列表中是否存在指定元素
boolean remove(Object o)
//从列表中删除元素
Object remove(int index)
/**
*从列表中删除指定位置元素,
*起始索引位置从0开始
*/

 

List、Set和Map各有什么异同

List 接口存储一组不唯一,有序(插入顺序)的对象。

Set接口储存唯一,无序的对象。

Map接口是键值对形势。

和数组类型采用相同结构的是哪个集合:

java.util.ArrayList和java.util.Vector.都是采用数组形式来实现的。

什么是foreach循环:

foreach 语句为数组或对象集合中的每个元素重复一个嵌入语句组。

foreach形式

foreach(type  identifier in expression) statement

//idrntifer是表示集合元素的迭代变量。
//如果迭代变量为值类型,则无法修改的只读变量也是有效的。

//expression对象集合或数组表达式。
//集合元素的类型必须可以转换为 identifier 类型。请不要使用计算为 null 的表达式。

//statement表示需要执行的语句

//实例
int[] arr=new int[]{0,1,2,3,4};
foreach(int i in arr){
Console.Write(i);
}

 

Java中格式

for(元素类型type 元素变量x : 遍历对象obj){
    引用X的语句;
}
在java中的语法:for(type x : collection){}
//在collection中遍历每一个对象,对象是type类型的x.

//实例
public class Test {
public static void main(String[] args)
{
    int[] a = {1,2,3};
       for(int i : a){
            System.out.print(i + "O(∩_∩)O哈!");
       }
    }
}

 

线程和进程的区别:

 根本区别:进程是资源分配的最小单位,线程只是执行程序中的一个最小单位。

地址空间:进程有自己独立的地址空间,每启动一个进程,系统都会为其分配地址空间。线程没有独立的地址空间,同一进程的线程共享本进程的地址空间。

资源拥有:进程之间的资源是独立的。同一进程内的线程共享本进程的资源。

执行过程:每个独立的进程程有一个程序运行的通道口。但是线程不能独立执行,必须依存在应用程序中。

线程是处理机调度的基本单位,但是进程不是。

系统开销:进程执行开销大,线程执行开销小。

实现线程有哪几种方法:

1.继承Thread类:每个线程都是通过某个特定的Thread对象所对应的方法run( )来完成其操作的,方法run( )称为线程体。

               通过调用Thread类的start()方法来启动一个线程。

public class TestThread extends Thread {//自定义类继承Thread类
    //run()方法里是线程体
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(this.getName() + ":" + i);//getName()方法是返回线程名称
        }
    }
 
    public static void main(String[] args) {
        TestThread thread1 = new TestThread();//创建线程对象
        thread1.start();//启动线程
        TestThread thread2 = new TestThread();
        thread2.start();
    }
}

 

2.实现Runnable接口:实现Runnable接口的同时还可以继承某个类。

public class TestThread2 implements Runnable {//自定义类实现Runnable接口;
    //run()方法里是线程体;
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
    public static void main(String[] args) {
        //创建线程对象,把实现了Runnable接口的对象作为参数传入;
        Thread thread1 = new Thread(new TestThread2());
        thread1.start();//启动线程;
        Thread thread2 = new Thread(new TestThread2());
        thread2.start();
    }
}

 

(前两个方式线程执行完后都没有返回值,后两种是带返回值的)

3.实现Callable接口通过FutureTask包装器来创建Thread线程。

4.使用ExecutorService、Callable、Future实现有返回结果的多线程。

线程的生命周期是什么:

 创建-就绪-堵塞-礼让-死亡

线程休眠,线程强制执行,线程礼让以及他们的实现方法:

 线程休眠

public static void sleep(long millis) throws InterruptedException;
//millis为休眠时长,以毫秒为单位
//调用sleep()方法需处理InterruptedException异常

 线程强制执行

//线程A在运行期间,可以调用线程B的join()方法,让线程B和线程A联合
public static void main(String[] args) {
      Thread temp = new Thread(new MyThread());
         temp.start();
               for(int i=0;i<20;i++){
             if(i==5){                
                try {
                    temp.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                                }
                        }
                  }
}

//temp.join();阻塞主线程,子线程强制执行

 线程礼让

//暂停当前线程,允许其他具有相同优先级的线程获得运行机会
//该线程处于就绪状态,不转为阻塞状态
public static void yield();

//只是提供一种可能,但是不能保证一定会实现

 

什么情况下需要线程同步:

 当多个线程访问同一个对象,并且某些线程还想修改这个对象。这时需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面的线程使用完毕后,下一个线程再使用。

什么是流?流的常见种类有哪些?使用流的过程中需要注意哪些问题:

流是一个抽象、动态的概念,是一连串连续动态的数据集合。

流的常见种类有:

    1.输出流

    2.输入流

    3.字节流

    4.字符流

使用流的过程中需要注意:创建IO流,记得关流,否则数据更改无效

您可能有感兴趣的文章
什么是面向对象?

java之面向对象

面向对象的基本概念

Java基础之面向对象——类、对象、方法

0007面向对象的编程思想、类与对象的概念、类的成员、类的声明与对象的创建以及属性、方法的如何使用