java零碎知识汇总

1:教练和运动员案例(学生分析然后讲解)
乒乓球运动员和篮球运动员。
乒乓球教练和篮球教练。
为了出国交流，跟乒乓球相关的人员都需要学习英语。
请用所学知识：
分析，这个案例中有哪些抽象类，哪些接口，哪些具体类
代码：

//测试类

package presonman;


public class PersonTest {


public static void main(String[] args){
Psportman a=new Psportman();
a.setName("小明");
a.setAge(18);
System.out.println(a.getName()+"---"+a.getAge());
a.study();
a.sport();
a.work();
System.out.println("--------------------");

Ptrainer b=new Ptrainer();
b.setName("李岩");
b.setAge(33);
System.out.println(b.getName()+"---"+b.getAge());
b.study();
b.sport();
b.work();
System.out.println("--------------------");

Bsportman c=new Bsportman();
c.setName("小高");
c.setAge(17);
System.out.println(c.getName()+"---"+c.getAge());
c.sport();
c.work();
System.out.println("--------------------");

Btrainer d=new Btrainer();
d.setName("齐枫");
d.setAge(38);
System.out.println(d.getName()+"---"+d.getAge());
d.sport();
d.work();
}
}

//抽象类

package presonman;


public abstract class Person {


private String name;
private int age;

public Person() {
super();
}

public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}


public String getName() {
return name;
}


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


public int getAge() {
return age;
}


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

public abstract void sport();

}

//乒乓球类

package presonman;


public class PingPang extends Person {



public PingPang() {
super();
// TODO Auto-generated constructor stub
}


public PingPang(String name, int age) {
super(name, age);
// TODO Auto-generated constructor stub
}


@Override
public void sport() {
     System.out.println("乒乓球");
}


public void work(){
System.out.println("工作");
}
}

//篮球类

package presonman;


public class BasketBall extends Person {



public BasketBall() {
super();

}


public BasketBall(String name, int age) {
super(name, age);

}


@Override
public void sport() {
System.out.println("篮球");
}


public void work(){
System.out.println("工作");
}
}

//乒乓球运动员类

package presonman;


public class Psportman extends PingPang implements English {


public Psportman() {
super();

}


public Psportman(String name, int age) {
super(name, age);
}


@Override
public void study() {

System.out.println("学习英语");
}

public void work(){
System.out.println("乒乓球运动员");
}


}

//乒乓球教练类

package presonman;


public class Ptrainer extends PingPang implements English {



public Ptrainer() {
super();

}


public Ptrainer(String name, int age) {
super(name, age);

}


@Override
public void study() {
System.out.println("学习英语");
}

public void work(){
System.out.println("乒乓球教练");
}


}

//篮球运动员类

package presonman;


public class Bsportman extends BasketBall {


public Bsportman() {
super();

}


public Bsportman(String name, int age) {
super(name, age);


}
public void work(){
System.out.println("篮球运动员");
}


}

//接口

package presonman;


public interface English {


public abstract void study();
}

//篮球教练类

package presonman;


public class Btrainer extends BasketBall {


public Btrainer() {
super();

}


public Btrainer(String name, int age) {
super(name, age);

}


public void work(){
System.out.println("篮球教练");
}

}
2:final关键字可以干什么?有什么特点?
  final表示最终，不可更改。用于修饰类的时候，该类不可以被继承；修饰成员方法的时候，该方法不能被重写；修饰成员变量的时候，该成员变量变成常量，不能再更改。

3:final关键字的面试题?
A:修饰局部变量

   如果是基本类型，则该变量不能被改变，相当于是常量。

    如果是引用类型，则不能再分配内存空间，但是可以改变成员变量的值。
B:初始化时机

   在创建对象之前都可以

1）构造代码块中可以进行初始化

2）构造方法中可以进行初始化

3)定义成员变量的时候直接初始化

4:多态是什么，前提是什么?
  多态:一个事物在不同时刻体现出来的不同状态

前提条件：
         1）必须有继承关系(如果没有继承关系,谈不上多态!)
         2）必须有方法重写
         3）有父类引用指向子类对象:向上转型

5:多态中成员访问的特点?
成员变量 编译看左边,运行看左边
成员方法 编译看左,运行看右；（方法重写）
静态方法 编译看左,运行看左（与类直接相关）

6:多态的好处及弊端？如何解决多态的弊端？
好处:
    1)提高代码的维护性(由继承保证)
    2)提高代码的扩展性(由多态保证)
弊端
    不能访问子类的特有功能
解决方案
    1)创建子类的具体对象,来访问自己的特有功能;

    2)将父类引用强制转换为子类引用（向下转型）

7:什么是向上转型？什么是向下转型？

向上转型：有父类引用指向子类对象
向下转型:将父类的引用强制转换为子类的引用:前提必须有父类的引用存在;


8:抽象类概述及其特点?
指的是那些抽象出来的，没有具体对象的类，有点类似于模板，就像是电子商品，他自己本身并不是一个具体的东西，只是一个从具体事物中抽象出来的概念，他的具体实现可以是电视，手机，但是自身并不能创建自己的对象。
当一个类中如果有抽象功能(抽象方法)的时候,那么这个类一定要定义为抽象类!

 抽象类的子类的特点:

强制子类必须重写当前抽象的父类中所有的抽象方法
还可以提高代码的维护性(里面继承关系保证!)



9:抽象类成员特点?
成员变量:
         可以是变量也可以是自定义常量
构造方法:
         抽象类可以有构造方法:包括有参构造和无参构造
         作用:通过抽象类多态的形式:让子类进行数据的初始化
成员方法:
         可以有抽象方法,也可以有非抽象方法




10:抽象类的小问题
A:一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?

  可以，子类创建对象，自己不能实例化
B:abstract不能和哪些关键字共存
abstract不能和static,final,private修饰


11:接口的概述及其特点?
接口的概念:
           接口体现的是一种扩展功能。

接口不能实例化，里面的方法只能是抽象方法，而且不能有构造方法
12:接口的成员特点?
成员变量:
  只能是常量:存下默认修饰符:public static final (永远建议自己给出默认修饰符)
构造方法:
接口是没有构造方法的
成员方法:
  接口中的成员方法默认修饰符:public abstract(永远建议自己给出默认修饰符)


13:抽象类和接口的区别?
               1)成员的区别:
  成员变量:
  抽象类:成员变量可以是常量,也可以是变量
  接口:成员变量只能是一常量:存在默认修饰符:public static final
  构造方法:
  抽象类:可以有无参构造,有参构造方法
   作用:通过子类进行数据初始化(通过子类创建对象)
  接口:没有构造方法的
  成员方法的区别:
  抽象类:可以有抽象方法,也可以有非抽象方法
  接口:只能是抽象方法:存在默认修饰符:public abstract
 
  2)关系的区别:
  类与类的关系:
  继承关系:extends,java中只支持单继承,不支持多继承,但是可以多层继承!
  类与接口的关系:
  实现关系:implements,并且,一个类在继承另一个类的同时,可以实现多个接口
  接口与接口的关系
  继承关系:extends,可以支持单继承,也可以多继承!
  

第二天

2:形式参数和返回值问题
形式参数
基本类型

如果是基本类型，需要什么数据类型就传入什么数据类型。

引用类型

具体类：创建该类对象

抽象类：定义一个抽象类的子类，进行实例化创建对象

接口：创建该接口的子实现类的对象

返回值类型
基本类型

需要什么就返回该类型
引用类型

具体类：返回该类的对象

抽象类：返回该抽象类的子类对象
接口：返回该接口的子实现类对象



3:内部类的概述及访问特点
内部类：在一个类中定义另一个类，分为成员内部类和局部内部类
访问特点：

外部类名.内部类名 对象名 = new 外部类名.内部类名() ;

4:内部类的分类
答：成员内部类:在外部类的成员位置
    局部内部类:在外部了的局部位置定义的这个类


5:匿名内部类的格式和应用及面试题

是内部类的简化版格式，匿名内部类继承了该类(抽象类)或者是实现了该接口的子类对象!

声明：

new 接口名或者类名(){
  方法重写;
  }

匿名内部类面试题：
按照要求，补齐代码
interface Inter { void show(); }
class Outer { //补齐代码 }
class OuterDemo {
public static void main(String[] args) {
 Outer.method().show();
 }
}
要求在控制台输出”HelloWorld”

代码补全：

interface Inter2{
// void show() ;
public abstract void show() ;
}


class Outer8{
//补齐代码
public static Inter2  method(){ //返回值是一个接口

return new Inter2(){


@Override
public void show() {
System.out.println("helloworld");
}

} ;

}
}


//测试类
public class InnerClassTest2 {
public static void main(String[] args) {
Outer8.method().show();  
}
}

 

版权声明：本文为博主原创文章，未经博主允许不得转载。