12.13 Java基础11

考试题目讲解（对周末所做错题总结的补充）

1.以下程序输出结果为？ String s = null; System.out.println(s);

A.不输出

B.空字符串

C.null

D.编译出错

// 声明引用类型的默认值为null
static Person p; //类变量

public static void main(String[] args) {

String s = null;
System.out.println(s);

}

2.以下说法正确的是
A、不需要定义类，就能创建对象
B、对象一经声明就可以立即使用（声明：Age a;）
C、Java中的方法参数如果是对象,那么形参的变化会原样反应到实参上（相关内容还没教，要等到讲String）
D、new操作符动态地为对象按其指定的类型分配内存 ,并返回该类型的一个引用

3. 面向对象语言比面向过程语言更为高级，更有效率

A.对

B.错误（前半句可以说对，毕竟面向对象比面向过程少了指针这个麻烦，不过面向对象语言Java是编译型语言，效率比面向过程的汇编语言譬如C语言之类的底层语言要低。）

4.覆盖的方法和被覆盖的方法必须具有完全相同的方法名、参数列表和返回类型

A.对

B.错误（如果返回值类型为引用类型，子类方法的返回值类型要比父类小那也是重写，也就是方法的覆盖返回值类型不一定要完全相同。）

5.如果类中的成员变量只可以被同一包访问，则使用private约束符

A.对

B.错误（如果类中的成员变量只可以被同一包访问，要使用的约束符是default或者protected。）

6.abstract的method是可同时是static

A.对

B.错误(static修饰的方法可以用类名调用，对于abstract修饰的方法没有具体的方法实现，所以不能直接调用，也就是说abstract不可以与static共存。)

上周知识点回顾
OOP三个特征

封装：将类的内部细节隐藏起来，private私有化属性，提供公共的方法来访问私有的属性。
继承：如果A是B，那么我们称A为子类，B为父类。　A is B ; 公交车是交通工具吗？
子类继承父类的非私有的成员。构造方法不能被继承。
重写：子类中定义一个方法，修饰符，返回值类型，方法名，参数列表都一致，一定是重写。
不过如果返回值类型为引用类型，子类方法的返回值类型要比父类小也是重写，比如object和String。
方法的访问权限修饰符：子类修饰符必须大于或者等于父类方法的访问修饰符。
super:作用：出现在子类中，去调用父类的构造 super(); super.属性或者super.方法
多态不同对象对同一个消息作出不同的响应，过程和结果都不同。
new出来的多个对象-》方法名相同-->方法实现上有差异. 比如说吃eat，有狼吞虎咽，也有细嚼慢咽
实现1：父类，父类有一个方法eat; 子类重写父类eat的方法. 场景中有一个方法，参数是父类引用；
实际执行的时候，传递的是子类对象。传递哪个子类，调用就是哪个子类的方法。
实现2：接口,之后再说
如果要问面向对象的四大特征，那就除了封装、继承和多态，就要提到抽象。

抽象:对象->类从许多对象中去提取公共的属性和方法并形成类的过程，称为抽象。

抽象类与接口
抽象类

如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类，必须用abstract关键字来修饰。

[访问权限] abstract class 类名 {

成员列表

}

没有功能主体的方法称为抽象方法，也必须用abstract关键字来修饰，只有方法声明，没有方法体，且必须定义在抽象类中。

abstract意思是说，我不实现，子类去实现。

特点

抽象类不可以被实例化，也就是不可以用new创建对象，但有构造方法，是为了让子类进行初始化。

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

方法只有声明没有实现时，该方法就是抽象方法，需要用abstract来修饰，抽象方法必须定义在抽象类中，该类也必须被abstract来修饰。

抽象方法必须定义在抽象类中。但是抽象类中不一定有抽象方法，抽象类也可以有成员属性和非抽象的成员方法。

abstract与其他修饰符的关系:

final与abstract不能共存:

final修饰类代表不可以继承，修饰方法不可重写。

abstract修饰类就是用来被继承的，修饰方法就是用来被重写的。

static修饰的方法可以用类名调用，对于abstract修饰的方法没有具体的方法实现，所以不能直接调用，也就是说abstract不可以与static共存。

private修饰的只能在本类中使用，abstract方法是用来被子类进行重写的，有矛盾所以不能共存。
抽象类与普通类的异同

相同点：抽象类和普通类都是用来描述事物的，都在内部定义了成员。

不同点：

普通类有足够信息来描述事物，抽身象类描述事物的信息有可能不够充足；

普通类不能定义抽象方法，只能定义普通方法，抽象类中可以定义抽象方法，同时也可以定义普通方法；

普通类可以被实例化，抽象类不可以被实例化。

为了方便理解抽象，我们可以联想到新版愚公移山。移山（方法）不实现让儿子实现儿子也可以选择不实现，继续交给它的子类去实现。。
抽象练习

1.定义抽象类MyShape（图形）

定义抽象方法获取图形的长度和面积

2.定义子类Rect继承父类MyShape

定义自身特有的长和宽（成员变量） width height;

实现父类未实现的函数。

3.定义子类 Circle实现父类MyShape

定义自身特有的半径和圆周率（使用常量）实现父类为实现的方法。

代码：

public abstract class MyShape {

// 抽象方法获取图形的周长和面积
// 周长
public abstract void getGirth();

// 面积
public abstract void getArea();

}

public class Rect extends MyShape {

// 长方形的长和宽
private double height;
private double width;

public Rect() {
// TODO Auto-generated constructor stub
}

public Rect(double height, double width) {
super();
this.height = height;
this.width = width;
}

public double getHeight() {
return height;
}

public void setHeight(double height) {
this.height = height;
}

public double getWidth() {
return width;
}

public void setWidth(double width) {
this.width = width;
}

@Override
public void getGirth() {
// TODO Auto-generated method stub
double result = 2 * (width + height);
System.out.println("长方形的周长为" + result);
}

@Override
public void getArea() {
double result = width * height;
System.out.println("长方形的面积为" + result);
}
}

public class Circle extends MyShape {
private double r;// 半径
// 使用常量 final ->这个值只是我们内部用的，也不会setter和getter来封装了
private final double pi = Math.PI;

public Circle() {
// TODO Auto-generated constructor stub
}

public Circle(double r) {
super();
this.r = r;
}

public double getR() {
return r;
}

public void setR(double r) {
this.r = r;
}

@Override
public void getArea() {
// bigdecimal
// string
double result = pi * Math.pow(r, 2);
System.out.println("圆的面积为" + result);

}

@Override
public void getGirth() {
double result = 2 * pi * r;
System.out.println("圆的周长为" + result);

}
}

public class TestShape1 {

public static void main(String[] args) {
MyShape c = new Circle(5);
c.getArea();
c.getGirth();

Rect rect = new Rect();
rect.setHeight(10);
rect.setWidth(5);
rect.getArea();
rect.getGirth();
}
}

案例：

/**
* 形状类: ->周长,面积. 我说的这个形状类的周长是怎么计算？面积怎么实现?
* 每个形状都会有自己周长和面积，但是当我们说概念比较大的时候，不能确定形状，周长和面积也就不好确定.
*
* 通常用来做模板.
*
* @author Administrator
*
*/
public abstract class Shape {

public Shape() {
System.out.println("无参数构造");
}

// 抽象方法不用去实现 ,不用写 { }
// abstract 修饰符
// 这个类，只是许了一个愿.没有实现. 子类去实现.
public abstract void getGirth();
}
/**
* 子类继承抽象的父类，重写了抽象方法： getGirth()
*
* @author Administrator
*
*/
//class Circle extends Shape {
//
// private double r;
//
// public double getR() {
// return r;
// }
//
// public void setR(double r) {
// this.r = r;
// }
//
// public Circle() {
// // TODO Auto-generated constructor stub
// }
//
// public Circle(double r) {
// super();
// this.r = r;
// }
//
// // alt+/
// @Override
// public void getGirth() {
// // 周长
//
// System.out.println(3.14 * r * 2);
//
// }
//}

/**
* 子类继承父类也可以不实现抽象方法，继续抽象.
*
* @author Administrator
*
*/
abstract class SubShape extends Shape {

}

备注：抽象类是类中的一个特例，类有的：普通属性，静态属性，构造方法，普通方法，静态方法它都可以有.普通代码段，静态代码段也有，除此之外，它还可以有抽象方法。

final修饰类: 一人吃饱，全家不饿，要什么老婆，要什么孩子. 丁克。 这个类不能被继承
final abstract 不能同时用来修饰类。

public abstract class A {

// 1 普通属性
private int a;

// 2静态属性
public static int b = 1;

// 3可以有构造方法
public A() {
// TODO Auto-generated constructor stub
}

// 4 抽象方法
// final 这个类不能被重写.
// static 类有，又抽象?
public abstract void test1();

// 5.普通方法
public void test2() {

}

// 6. 静态方法
public static void test3() {

}

static {
System.out.println("普通代码段");
}

{
System.out.println("普通代码段");
}
}

接口

Java接口是一系列方法的声明，是一些抽象的集合，一个接口只有抽象方法（只有定义而没有被实现），没有方法的实现。简言之，接口就是特殊的抽象类，即所有方法都是抽象方法的抽象类就是Java中的接口。

格式

[修饰符] interface 接口名{

[public] [static] [final] 数据类型变量名;

[public] [abstract] 方法( );

}

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

公共静态的常量 public static final 修饰的变量变常量，该值不能改变，只能读。声明成员变量列表时，即便没有修饰符，它们也是public static final的，这是固定的。

修饰符：可选，用于指定接口的访问权限，可选值为public。即使省略，也依然是public abstract（公共抽象方法）的。（jdk1.8之后一个默认方法: 使用default关键字来修饰的方法）

接口中可以包含: 静态方法

接口名：必选参数，用于指定接口的名称，接口名必须是合法的Java标识符。一般情况下，要求首字母大写。

示例：

public interface IMonkey {

// final field 使用final修饰的属性，表示是一个常量
// The blank final field a may not have been initialized
// int a;

int A = 1;
// Illegal modifier for the interface field IMonkey.B;
// only public, static & final are permitted
// private static int B =2;

public static int B = 2;

static final int C = 3;

public static final int D = 4;

// 抽象方法
void test1();

abstract void test2();

public abstract void test3();

// Abstract methods do not specify a body
// jdk1.8之后可以有一个默认的方法
default void test4() {
System.out.println("default");
}

// 静态方法 ->IMonkey 接口所有
public static void test5() {
System.out.println("静态方法");
}
}

类与接口的关系

[访问权限修饰符] class 类名 [extends 父类名] [implements 接口列表]{

必须重写接口中的方法( ){ }

}

类与接口之间是实现关系，类实现接口（多实现），避免了单继承的局限性。

接口不可以被实例化。

实现了接口的实现类必须重写接口中所有抽象方法后，这个子类才可以被实例化，否则子类也需要声明为抽象类，不然会报错。

一个类可以实现多个接口，多个接口用逗号分隔。

一个类在继承另一个类同时，还可以实现多个接口。

接口与接口的关系

[修饰符] interface 接口名 extends 接口名，接口名 {

接口中的方法( ){

}

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

接口与抽象类的区别

	abstract class	interface
属性	不用限制	public 静态 final 常量
构造方法	可有可无	没有
普通方法	可以有具体方法	必须是public抽象方法
子类	单一继承	多重实现（接口继承接口时为多重继承）

抽象类是继承 is a关系（所属关系）在定义该体系的基本共性内容

接口是实现是like a关系（不所属关系）在定义该体系额外功能

接口可实现多继承的原因

Java类的继承是单一继承，Java接口的继承是多重继承；

接口可实现多继承原因分析：

不允许类多重继承的主要原因是，如果A同时继承B和C，而B和C同时有一个D方法，A无法确定该继承哪一个

接口全都是抽象方法，不存在实现冲突，继承谁都可以，所以接口可继承多个接口。

类与类之间的关系
类之间的关联关系-一对一：关联表示has-a关系，如学生拥有个课程，往往表现为B作为A的属性存在（A关联B）

public class Boy {
private Girl girl;
private int years;

public Boy() {
super();
}
}

当然，如果是一对多的关系，比如一个人可以有多个荣誉证书，我们可以使用数组或集合来描述这个关系。

依赖关系

依赖关系是一种使用关系，特定事物的改变有可能会影响到使用该事物的事物。所谓依赖就是某个对象的功能依赖于另外的某个对象，而被依赖的对象只是作为一种工具在使用，而并不持有对它的引用。

依赖体现了“ use a”关系，依赖关系一般使用方法的参数体系。

public class Vehicle {
private double weight;
private String brand;

public Vehicle() {
// TODO Auto-generated constructor stub
}

public void crush() {
System.out.println("挖掘机压过路面");
}
}

public class Boy1 {
private String name;

public Boy1() {
// TODO Auto-generated constructor stub
}

public void drive(Vehicle v) {//改变挖掘机的状态开起来
v.crush();//相关改变的操作
}
}

包
包的命名规范

第一级指该项目的类型，如com,org,gov等，

第二级指项目所开发或者运行的公司名称，如：chinasofti,icss,huawei,etc等

第三级指项目的名称，如：corejava,bcms,oa,erp等

第四级指项目模块的名称，如：bean,action,exception,oop01等

成员访问控制符总结如下：

12.13 Java基础11

导航

公告