2019-7-5 [JavaSE] Math随机数 Random 继承的语法和好处 里氏替换原则 方法重写 super 父类 子类 继承传递性 Object类

1.Math类

实例:

		//ceil返回大于等于 45.78的最小整数的double形式
		System.out.println(Math.ceil(45.78));//46.0
		//floor返回小于等于45.78的最大整数的double形式
		System.out.println(Math.floor(45.78));//45.0
		//round四舍五入为一个整数long
		System.out.println(Math.round(45.78));//46
		//pow（底数，指数） - 》 double
		System.out.println(Math.pow(2, 3));//8.0

Math类随机数:

//		double n = 自动生成：
		double n = Math.random();
		//小数： [0.0 , 1.0）
		System.out.println(n);
		//
		System.out.println((int)(n*10));// 0 -9
		// [最小值 ，最大值]
		(int)(Math.random*(最大值-最小值+1) + 最小值)'

Random类随机数：

	 	System.out.println("--------------------------------");
		//位于 util包下
		Random rd = new Random();
		// [0.0 , 1.0)
		System.out.println(rd.nextDouble());
		//int范围内的
		System.out.println(rd.nextInt());
		// [0,上限) 随机整数
//		System.out.println(rd.nextInt(上限));
		System.out.println(rd.nextInt(9));
		
//----------------------------------------------------
		System.out.println("-----------种子----------------");
		//                   随机种子
		Random rd1 = new Random(6);
		Random rd2 = new Random(6);
		System.out.println(rd1.nextDouble());
		System.out.println(rd2.nextDouble());
//同一个种子的随机数都是相同的，地址是不同的
		Random fd3 = new Random();
		System.out.println(fd3.nextDouble());

编程实例：

		int r = (int)(Math.random()*10 + 1);
		Scanner input = new Scanner(System.in);
		System.out.println("--输入一个数字：");
		int num = input.nextInt();
		if(num == r) {
			System.out.println("中奖了");
		}else {
			System.out.println("谢谢参与");
		}

2.继承

继承：根据已有的类派生出新类的技术。

Java支持单一继承。

语法：

继承好处：

1.代码重用。
 2.程序的维护。（高耦合）

示例：

继承： 子类 可以继承父类中的功能，就像是在自己的类中定义的一样使用。

注意：不能继承的：

1.父类中私有的成员 。
2.父类和子类不在同包，父类中默认访问权限的成员；
3.构造。

里氏替换原则

子类 是 父类，子类 可以完全替换掉父类。
实例：

class Parent{
	String s;
	Parent(){}
	Parent(String s){
		System.out.println("父类构造");
	}
	public void f() {
		System.out.println("Parent_f");
	}
}
class Child extends Parent{
	/*默认
	  Child(){
	    super();    
	  }
	 */
	Child(){
		super("hello");
		System.out.println("子类构造");
	}
	int x;
//	Child(int x){
//		this();
//		this.x = x;
//	}
	@Override
	public void f() {
		System.out.println("Child_f");
	}
	public void show() {
//		f();//重写后的
		super.f();
	}
}
public class TestOverrid2 {
	public static void main(String[] args) {
		Child child = new Child();
		child.f();
		child.show();
	}
}

3.方法重写

子类重写(覆盖)了父类的方法：
1.子类中；
2.实例成员方法；
3.方法名必须相同；
4.参数列表相同；
特殊： 父类擦除后与子类相同。
5.返回值类型相同；
特殊：可以是父类的子类型
6.访问权限不能比父类更严格；（更低）
7.异常处理不能比父类范围更大。

实例：

class Parent{
	public void f() {
		System.out.println("Parent_f");
	}
}
class Child extends Parent{
	@Override 
	public void f() {
		System.out.println("Child_f");
	}
}

4.super

super:调用父类的成员。
父类和子类方法同名，super区分；
**super()**调用父类构造的。
注意：位置：子类构造中；子类构造中的第一行代码处。

创建子类对象时，一定会先调用父类构造，然后再调用子类构造。
子类构造中 没有显示的super()或this()，那么编译器一定会自动生成一个**super()**调用父类的构造。
父类中只显示定义了带参的构造，那么子类构造中必须显示调用
super(参数)父类的带参构造。（特殊）
参数从主函数到父类到子类到运算流程图如下图：

图示代码如下：

父类：超类 ，基类

//父类：超类 ，基类
public class Teacher {
	private String name;
	public Teacher(String name) {// name = "郭芙"
		this.name = name;//this.name = "郭芙“
	}
	public String getName() {
		return name;
	}

	public void giveLesson() {
		System.out.println(name + "讲数学课");
	}
}

子类：派生类

// 子类：派生类
public class JavaTeacher extends Teacher{
	private String tattoo;
	public JavaTeacher(String name,String tattoo) {//String name = "郭芙"
		super(name);//郭芙
		this.tattoo = tattoo;
	}
	public void sing() {
		System.out.println("唱歌");
	}
	public void giveLesson() {
		System.out.println(getName() + "讲java课，纹身是：" + tattoo);
	}
}

主类

public class TestTeacher {
	public static void main(String[] args) {
		JavaTeacher guofu = new JavaTeacher("郭芙","米老鼠");
		guofu.giveLesson();
	}
}

5.继承传递性

子类可以继承 直接父类和间接父类的功能；
super调用的是extends 直接父类的。

class Greandpa{ // Object类
	String name;
	
	public Greandpa() {
		super();// Object类的构造	
	}

	public void eat() {
		System.out.println("吃粥");
	}
}
class Father extends Greandpa{
	String hobby;
	
	public Father() {
		super();
	}

	public void eat() {
		System.out.println("吃米饭");
	}
}
class Son extends Father{
	String tattoo;
	
	public Son() {
		super();

	}
	public void eat() {
		System.out.println("吃馒头");
	}
	public void show() {
		super.eat();//?
	}
}
public class TestOverrid3 {

	public static void main(String[] args) {
		Son son = new Son();
		son.show();
	}
}

6.Object类

Object 类：所有类的父类（超类）。
equals(): Object类的方法，作用比较地址（比较是否为同一个对象）。

原码：

 public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    //对应的字符比较
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

7.编写:寻找水仙花数

水仙花数
三位数
abc -> a 立方 + b立方 + c立方 == abc
153 ,370 ,371 ,407

int a, b,c ;
		for(int i = 100; i <= 999; i ++) {
			a = i % 10;
			b = i / 10 % 10;
			c = i /10 / 10;// i / 100
			if((int)(Math.pow(a, 3) + Math.pow(b, 3) + Math.pow(c, 3)) == i) {
				System.out.println(i);
			}

8.编写:利用父类子类设计彩打和黑白打印

class Printer{
	private String content;
	public Printer() {
	}
	public Printer(String content) {
		this.content = content;
	}
	public String getContent() {
		return content;
	}
	public void print() {
		System.out.println("打印：" + content);
	}
}
class ColorPrinter extends Printer{
	public ColorPrinter(String content) {
		super(content);
	}
	@Override
	public void print() {
		System.out.println("彩色打印" + getContent());
	}
}
public class TestPrinter_exam {
	public static void main(String[] args) {
		ColorPrinter color = new ColorPrinter("照片");
		color.print();
	}
}

》》》彩色打印照片

9.编写:1-10范围内的随机数字猜数字

1-10范围内的随机数字猜数字
3次以内:天才
3-5次：还可以
大于5次：太笨了

import java.util.Random;
import java.util.Scanner;
/**
 * 练习：随机数
 * 猜数字
 * 1-10范围内的随机数字猜数字
 *
 */
public class TestRandom_exam {

	public static void method() {
		Scanner input = new Scanner(System.in);
		Random rd = new Random();
		int r = rd.nextInt(10) + 1;
		int num;
		int i = 1; 
		for(; i <= 5; i++) {
			System.out.println("--输入数字：");
			num = input.nextInt();
			if(num == r) {
				System.out.println("猜对了");
				break;
			}else if(num > r) {
				System.out.println("猜大了");
			}else {
				System.out.println("猜小了");
			}
		}
		if(i >= 1 && i <= 3) {
			System.out.println("天才");
		}else if(i >= 4 && i <= 5) {
			System.out.println("还可以");
		}else {
			System.out.println("太笨了");
		}
	}
	public static void main(String[] args) {
		method();
	}
}

10.注意

1.具备重复的实物设置继承比较好
2.子类继承父类全部功能没并且还可以开发子类的自己的功能
3.父类和子类有着很高的紧密程度
（高耦合）如父类增加了功能，子类也会将增加同样的功能，减少功能也是一样的
4.extands继承不能继承private声明的
5.父类的构造方法不能继承，但是可以调用。
6.默认类同包可以，不同包不可以继承
7.protected声明的只要是继承就可以，不同包也可以
8.public任何地方都可以见
9.当子类重写之后，在调用相同的方法优先调用重写的方法
10.super关键字来区分
11.this（）是用来调用本类构造器
super（）是用来调用父类构造方法
12,.搞懂数据传递细节