黑马程序员_Java(Math类,继承,多态,接口)

-------
android培训、java培训、期待与您交流！ ----------
生活中的花朵,需要汗水的浇灌,相信自己是最好的!
Math类

A:是针对数学进行操作的类

B:没有构造方法，因为它的成员都是静态的

C:产生随机数

public static double random(): [0.0,1.0)

D:如何产生一个1-100之间的随机数

int number = (int)(Math.random()*100)+1;

E:程序实现
class MathDemo {

public static void main(String[] args) {

//获取一个随机数

//double d = Math.random();

//System.out.println(d);

//需求：我要获取一个1-100之间的随机数

for(int x=0; x<100; x++) {

int number = (int)(Math.random()*100)+1;

System.out.println(number);

}

}

代码块

(1)用{}括起来的代码。

(2)分类：

A:局部代码块

用于限定变量的生命周期，及早释放，提高内存利用率。

B:构造代码块

把多个构造方法中相同的代码可以放到这里，每个构造方法执行前，首先执行构造代码块。

C:静态代码块

对类的数据进行初始化，仅仅只执行一次。

(3)静态代码块,构造代码块,构造方法的顺序问题?

静态代码块 > 构造代码块 > 构造方法

(4)代码实现
class Student {

static {

System.out.println("Student 静态代码块");

}

{

System.out.println("Student 构造代码块");

}

public Student() {

System.out.println("Student 构造方法");

}

}

class StudentDemo {

static {

System.out.println("林青霞都60了，我很伤心");

}

public static void main(String[] args) {

System.out.println("我是main方法");

Student s1 = new Student();

Student s2 = new Student();

}

}

继承

(1)把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系，

这多个类就具备了这些内容。这个关系叫继承。

(2)Java中如何表示继承呢?格式是什么呢?

A:用关键字extends表示

B:格式：

class 子类名 extends 父类名 {}

(3)继承的好处：

A:提高了代码的复用性

B:提高了代码的维护性

C:让类与类产生了一个关系，是多态的前提

(4)继承的弊端：

A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。

原则：低耦合，高内聚。

耦合：类与类的关系

内聚：自己完成某件事情的能力

B:打破了封装性

(5)Java中继承的特点

A:Java中类只支持单继承

B:Java中可以多层(重)继承(继承体系)

(6)继承的注意事项：

A:子类不能继承父类的私有成员

B:子类不能继承父类的构造方法，但是可以通过super去访问

C:不要为了部分功能而去继承

(7)什么时候使用继承呢?

A:继承体现的是：is a的关系。

B:采用假设法

(8)Java继承中的成员关系

A:成员变量

a:子类的成员变量名称和父类中的成员变量名称不一样，这个太简单

b:子类的成员变量名称和父类中的成员变量名称一样，这个怎么访问呢?

子类的方法访问变量的查找顺序：

在子类方法的局部范围找，有就使用。

在子类的成员范围找，有就使用。

在父类的成员范围找，有就使用。

找不到，就报错。

B:构造方法

a:子类的构造方法默认会去访问父类的无参构造方法

是为了子类访问父类数据的初始化

b:父类中如果没有无参构造方法，怎么办?

子类通过super去明确调用带参构造

子类通过this调用本身的其他构造，但是一定会有一个去访问了父类的构造

让父类提供无参构造

C:成员方法

a:子类的成员方法和父类中的成员方法名称不一样，这个太简单

b:子类的成员方法和父类中的成员方法名称一样，这个怎么访问呢?

通过子类对象访问一个方法的查找顺序：

在子类中找，有就使用

在父类中找，有就使用

找不到，就报错

(9)两个面试题：

A:Override和Overload的区别?Overload是否可以改变返回值类型?

B:this和super的区别和各自的作用?

(10)数据初始化的面试题

A:一个类的初始化过程

B:子父类的构造执行过程

C:分层初始化

(11)案例：

A:父子之间的继承

class Father {

/*

public Father() {

System.out.println("Father的无参构造方法");

}

*/

public Father(String name) {

System.out.println("Father的带参构造方法");

}

}

class Son extends Father {

public Son() {

super("随便给");

System.out.println("Son的无参构造方法");

//super("随便给");

}

public Son(String name) {

//super("随便给");

this();

System.out.println("Son的带参构造方法");

}

}

class ExtendsDemo7 {

public static void main(String[] args) {

Son s = new Son();

System.out.println("----------------");

Son ss = new Son("林青霞");

}

}

final关键字
(1)是最终的意思，可以修饰类，方法，变量。

(2)特点：

A:它修饰的类，不能被继承。

B:它修饰的方法，不能被重写。

C:它修饰的变量，是一个常量。

(3)面试相关：

A:局部变量

a:基本类型 值不能发生改变

b:引用类型 地址值不能发生改变，但是对象的内容是可以改变的

B:初始化时机

a:只能初始化一次。

b:常见的给值

定义的时候。

构造方法中。

多态

(1)同一个对象在不同时刻体现出来的不同状态。

(2)多态的前提：

A:有继承或者实现关系。

B:有方法重写。

C:有父类或者父接口引用指向子类对象。

多态的分类：

a:具体类多态

class Fu {}

class Zi extends Fu {}

Fu f = new Zi();

b:抽象类多态

abstract class Fu {}

class Zi extends Fu {}

Fu f = new Zi();

c:接口多态

interface Fu {}

class Zi implements Fu {}

Fu f = new Zi();

(3)多态中的成员访问特点

A:成员变量

编译看左边，运行看左边

B:构造方法

子类的构造都会默认访问父类构造

C:成员方法

编译看左边，运行看右边

D:静态方法

编译看左边，运行看左边

为什么?

因为成员方法有重写。

(4)多态的好处：

A:提高代码的维护性(继承体现)

B:提高代码的扩展性(多态体现)

(5)多态的弊端：

父不能使用子的特有功能。

现象：

子可以当作父使用，父不能当作子使用。

(6)多态中的转型

A:向上转型

从子到父

B:向下转型

从父到子
案例体现:
class Animal {

public void eat(){}

}

class Dog extends Animal {

public void eat() {}

public void lookDoor() {

}

}

class Cat extends Animal {

public void eat() {

}

public void playGame() {

}

}

class DuoTaiDemo5 {

public static void main(String[] args) {

//内存中的是狗

Animal a = new Dog();

Dog d = (Dog)a;

//内存中是猫

a = new Cat();

Cat c = (Cat)a;

//内存中是猫

Dog dd = (Dog)a; //ClassCastException

}

}

3:抽象类

(1)把多个共性的东西提取到一个类中，这是继承的做法。

但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体。

也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。

所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体。

而一个没有具体的方法体的方法是抽象的方法。

在一个类中如果有抽象方法，该类必须定义为抽象类。

(2)抽象类的特点

A:抽象类和抽象方法必须用关键字abstract修饰

B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类

C:抽象类不能实例化

D:抽象类的子类

a:是一个抽象类。

b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。

(3)抽象类的成员特点：

A:成员变量

有变量，有常量

B:构造方法

有构造方法

C:成员方法

有抽象，有非抽象

(4)抽象类的几个小问题

A:抽象类有构造方法，不能实例化，那么构造方法有什么用?

用于子类访问父类数据的初始化

B:一个类如果没有抽象方法,却定义为了抽象类，有什么用?

为了不让创建对象

C:abstract不能和哪些关键字共存

a:final 冲突

b:private 冲突

c:static 无意义

4:接口

(1)接口的特点：

A:接口用关键字interface修饰

interface 接口名 {}

B:类实现接口用implements修饰

class 类名 implements 接口名 {}

C:接口不能实例化

D:接口的实现类

a:是一个抽象类。

b:是一个具体类，这个类必须重写接口中的所有抽象方法。

(2)接口的成员特点：

A:成员变量

只能是常量

默认修饰符：public static final

B:构造方法

没有构造方法

C:成员方法

只能是抽象的

默认修饰符：public abstract

(3)类与类,类与接口,接口与接口

A:类与类

继承关系，只能单继承，可以多层继承

B:类与接口

实现关系，可以单实现，也可以多实现。

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

C:接口与接口

继承关系，可以单继承，也可以多继承

interface Inter {

public int num = 10;

public final int num2 = 20;

public static final int num3 = 30;

//错误: 需要<标识符>

//public Inter() {}

//接口方法不能带有主体

//public void show() {}

//abstract void show(); //默认public

public void show(); //默认abstract

}

//接口名+Impl这种格式是接口的实现类格式

/*

class InterImpl implements Inter {

public InterImpl() {

super();

}

}

*/

class InterImpl extends Object implements Inter {

public InterImpl() {

super();

}

public void show() {}

}

//测试类

class InterfaceDemo2 {

public static void main(String[] args) {

//创建对象

Inter i = new InterImpl();

System.out.println(i.num);

System.out.println(i.num2);

//i.num = 100;

//i.num2 = 200;

//System.out.println(i.num); //无法为最终变量num分配值

//System.out.println(i.num2);//无法为最终变量num2分配值

System.out.println(Inter.num);

System.out.println(Inter.num2);

System.out.println("--------------");

}

}