表格
| 发生 | fads | fasd |
|---|---|---|
| afa | fas | fasd |
| fas | fasd | |
| fas | fasd | fasdf |
分割线
无序列表
- 发顺丰
- 发生a
- 分啊
- 爱的方式
- 阿道夫
- 啊a
- 阿萨德
- 阿斯蒂芬
有序列表
- 发顺丰
- 发送到啊
- 打发时间
- 发生
- 算法
- 发送到
- 发
- 发送到
- 安抚
引用
阿斯蒂芬啊打发阿萨德大赛奥德赛发的 阿斯蒂芬啊打发阿萨德大赛奥德赛发的 阿斯蒂芬啊打发阿萨德大赛奥德赛发的 阿斯蒂芬啊打发阿萨德大赛奥德赛发的 阿斯蒂芬啊打发阿萨德大赛奥德赛发的 阿斯蒂芬啊打发阿萨德大赛奥德赛发的 发斯蒂芬大赛
的所噶但是
TODO
- ffhj
- gasg
- aggasg
代码块
import sys
def fun:
pass
引言
部署
发生gas但看见阿拉基爱过后阿里加了个哈罗咖喱火锅拉市纪委IE人哈嘎两年来
查的出
擦上档次
cadsc
嗷嗷的阿达adac
擦上档次
擦上档次
1、 接口
www.coolpoker.cn/assess?round=&position=&self_cards=&public_cards&chips=&public_chips=&self_chips=
2、参数介绍
- round：int，范围0~3
- position：int，范围0~7，0代表dealer
牌的标识：
- 1~13分别为A23456789TJQK
- 梅花（Clubs）：c，方片（Diamonds）：d，红桃（Hearts）：h，黑桃（Spades）：s
- 比如2c代表梅花2，Ah地表红桃A
- self_cards：string，自己的手牌，比如5d7h，代表方片5和红桃7两张牌
- public_cards：string，代表当前的公牌，格式同上
- chips_index: uint，当前round是第几次加注，大于0
- chips：int，跟注的筹码数
- public_chips:int，底池的筹码数
- self_chips：int，自己手中的筹码数
3、返回结果
json格式
{
"ret_code": 0, // 接口正常返回0，只有在该字段为0的情况下才能按其它字段操作
"ret_msg": "ok",
"op": 0, // 0:drop手牌；1：call，跟注；2：raise，增加筹码，具体增加量由raise_num指定
"raise_num": 1
}
4、TODO
- 对手加注
- 筹码量
- 跟注人
java类静态
对于静态变量、静态初始化块、变量、初始化块、构造器，它们的初始化顺序以此是
（静态变量、静态初始化块）>（变量、初始化块）>构造器。
下面的测试代码可验证这一点：
public class InitialOrderTest {
// 静态变量
public static String staticField = "静态变量";
static {
System.out.println(staticField);
System.out.println("静态初始化块");
}
// 变量
public String field = "变量";
{
System.out.println(field);
System.out.println("初始化块");
}
// 构造器
public InitialOrderTest() {
System.out.println("构造器");
}
public static void main(String[] args) {
new InitialOrderTest();
}
}
运行以上代码，我们会得到如下的输出结果：
静态变量
静态初始化块
变量
初始化块
构造器
这与上文中说的完全符合。
那么对于继承情况下又会怎样呢？我们仍然以一段测试代码来获取最终结果：
class Parent {
// 静态变量
public static String p_StaticField = "父类--静态变量";
static {
System.out.println(p_StaticField);
System.out.println("父类--静态初始化块");
}
// 变量
public String p_Field = "父类--变量";
{
System.out.println(p_Field);
System.out.println("父类--初始化块");
}
// 构造器
public Parent() {
System.out.println("父类--构造器");
}
}
public class SubClass extends Parent {
// 静态变量
public static String s_StaticField = "子类--静态变量";
static {
System.out.println(s_StaticField);
System.out.println("子类--静态初始化块");
}
// 变量
public String s_Field = "子类--变量";
{
System.out.println(s_Field);
System.out.println("子类--初始化块");
}
// 构造器
public SubClass() {
System.out.println("子类--构造器");
}
// 程序入口
public static void main(String[] args) {
new SubClass();
}
}
运行结果：
父类--静态变量
父类--静态初始化块
子类--静态变量
子类--静态初始化块
父类--变量
父类--初始化块
父类--构造器
子类--变量
子类--初始化块
子类--构造器
现在，结果已经不言自明了。大家可能会注意到一点，那就是，并不是父类完全初始化完毕后才进行子类的初始化，
实际上子类的静态变量和静态初始化块的初始化是在父类的变量、初始化块和构造器初始化之前就完成了。
那么对于静态变量和静态初始化块之间、变量和初始化块之间的先后顺序又是怎样呢？
是否静态变量总是先于静态初始化块，变量总是先于初始化块就被初始化了呢？实际上这取决于它们在类中出现的先后顺序。
我们以静态变量和静态初始化块为例来进行说明。 同样，我们还是写一个类来进行测试：
public class TestOrder {
// 静态变量
public static TestA a = new TestA();
// 静态初始化块
static {
System.out.println("静态初始化块");
}
// 静态变量
public static TestB b = new TestB();
public static void main(String[] args) {
new TestOrder();
}
}
class TestA {
public TestA() {
System.out.println("Test--A");
}
}
class TestB {
public TestB() {
System.out.println("Test--B");
}
}
运行上面的代码，会得到如下的结果：
Test--A
静态初始化块
Test--B
大家可以随意改变变量a、变量b以及静态初始化块的前后位置，就会发现输出结果随着它们在类中出现的前后顺序而改变，
这就说明静态变量和静态初始化块是依照他们在类中的定义顺序进行初始化的。同样，变量和初始化块也遵循这个规律。
了解了继承情况下类的初始化顺序之后，如何判断最终输出结果就迎刃而解了。
测试函数：
public class TestStaticCon {
public static int a = 0;
static {
a = 10;
System.out.println("父类的非静态代码块在执行a=" + a);
}
{
a = 8;
System.out.println("父类的非静态代码块在执行a=" + a);
}
public TestStaticCon() {
this("a在父类带参构造方法中的值：" + TestStaticCon.a); // 调用另外一个构造方法
System.out.println(a);
System.out.println("父类无参构造方法在执行a=" + a);
}
public TestStaticCon(String n) {
System.out.println(n);
System.out.println(a);
}
public static void main(String[] args) {
TestStaticCon tsc = null;
System.out.println("!!!!!!!!!!!!!!!!!!!!!");
tsc = new TestStaticCon();
}
}
运行结果：
父类的非静态代码块在执行a=10
!!!!!!!!!!!!!!!!!!!!!
父类的非静态代码块在执行a=8
a在父类带参构造方法中的值：10
8
8
父类无参构造方法在执行a=8
结论：静态代码块是在类加载时自动执行的，非静态代码块是在创建对象时自动执行的代码，不创建对象不执行该类的非静态代码块。且执行顺序为静态代码块------非静态代码块----构造函数。
扩展：静态代码块 与 静态方法
一般情况下,如果有些代码必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的;
需要在项目启动的时候就初始化,在不创建对象的情况下,其他程序来调用的时候,需要使用静态方法,这种代码是被动执行的.
两者的区别就是:静态代码块是自动执行的; 静态方法是被调用的时候才执行的.
作用:静态代码块可用来初始化一些项目最常用的变量或对象;静态方法可用作不创建对象也可能需要执行的代码
阿里笔试题：
求下面这段代码的输出：
public class Test1 {
public static int k = 0;
public static Test1 t1 = new Test1("t1");
public static Test1 t2 = new Test1("t2");
public static int i = print("i");
public static int n = 99;
public int j = print("j");
{
print("构造块");
}
static {
print("静态块");
}
public Test1(String str){
System.out.println((++k)+":"+str+" i="+i+" n="+n);
++i;++n;
}
public static int print(String str){
System.out.println((++k)+":"+str+" i="+i+" n="+n);
++n;
return ++i;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Test1 t = new Test1("init");
}
}
运行结果：
1:j i=0 n=0
2:构造块 i=1 n=1
3:t1 i=2 n=2
4:j i=3 n=3
5:构造块 i=4 n=4
6:t2 i=5 n=5
7:i i=6 n=6
8:静态块 i=7 n=99
9:j i=8 n=100
10:构造块 i=9 n=101
11:init i=10 n=102
public class Main{
{
a=6;
}
int a=9;
public static void main(String[] args){
System.out.printf(new Main().a);
}
}
输出9
解释：初始化块和变量都不是静态的，因此按照声明顺序
public class Main{
{
a=6;
}
static int a=9;
public static void main(String[] args){
System.out.printf(new Main().a);
}
}
输出6
public class Main {
Main(){a=10;}
int a=9;
{
a=6;
}
public static void main(String[] args){
System.out.printf(new Main().a);
}
}
输出10
javap -verbose Main.class 查看字节码:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: aload_0
5: bipush 9
7: putfield #2 // Field a:I
10: aload_0
11: bipush 6
13: putfield #2 // Field a:I
16: aload_0
17: bipush 10
19: putfield #2 // Field a:I
22: return
Ref: http://ini.iteye.com/blog/2007835
1702
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
