// 对a减1
a++;
a += 1;
a = a + 1;
// 对a加1
a--;
a -= 1;
a = a - 1;

x = 0011 1100
y = 0000 1101
-----------------
x & y = 0000 1100
x | y = 0011 1101
x ^ y = 0011 0001
~x  = 1100 0011
x << 2 = 1111 0000
x >> 2 = 0000 1111
x >>> 2 = 0000 1111

booleanExpression ? valueWhenTrue : valueWhenFalse

if (x >= 0) {
    y = x;
} else {
    y = -x;
}
// 可以转换成
y = x >= 0 ? x : -x;

if (布尔表达式) {
    //布尔表达式的值为true将执行的代码
}

if (布尔表达式) {
    //布尔表达式的值为true将执行的代码
} else {
    //布尔表达式的值为false将执行的代码
}

if (布尔表达式1) {
    //布尔表达式1的值为true将执行的代码
} else if (布尔表达式2) {
    //布尔表达式1为false,布尔表达式2为true将执行的代码
} else if (布尔表达式3) {
    //布尔表达式1为false,布尔表达式2为false,布尔表达式3的值为true将执行的代码
} else {
    //以上布尔表达式都不为true将执行的代码
}

switch(expression){
    case value :
        //语句
    break; //可选
    case value :
        //语句
    //可以有任意数量的case语句
    default : // 可选
        //语句
}

// 没有显示定义构造器,系统会默认给一个构造器因此我们可以用new来调用默认构造器,构造器也可以用`public`和`private`来修饰,用了`private`外部就不能用new方法来运行
class Post {
    private String title;
    private String content;
}
Post post = new Post();

class Post {
    private String title;
    private String content;
    // 构造器重载
    // 如果显式定义了构造器后,需要传相应的参数 Post post = new Post();的方法会报错,除非显式增加一个没有参数的构造器
    public Post(String title, String content) {
        // 如果类的方法或者构造器的参数与自己的成员变量重名的时候,就可以使用this来进行区别,但是
        this.title = title;
        this.content = content;
    }
}
Post post = new Post("文章的标题", "文章的内容");

class Post {
    private String title;
    private String content;

    // 第一个构造器
    public Post(String title) {
        this.title = title;
    }

    // 第二个构造器
    // 在这个构造器中,this(title);这一行代码表示调用第一个构造器. 在构造器比较复杂时,这种方式可以让代码更加简洁
    public Post(String title, String content) {
        this(title);
        this.content = content;
    }
}

class Post {
    // 成员变量可以直接赋值
    private String title = "默认标题";
    private String content = "默认内容";

    // 通过final关键字赋值
    private String content = initContent();
    private final String initContent() {
        return "默认内容";
    }

    // 通过构造块初始化
    {
        title = "默认标题";
        content = "默认内容";
    }
}

public class Post {

    private String title;
    private String content;

    public static int count = 0;

    public Post(){
        count++;
    }
}

public class Post {

    private String title;
    private String content;

    private static int count = 0;

    public Post(){
        count++;
    }

    public static int getCount(){
        return count;
    }
}

public class Post {

    private String title;
    private String content;

    // 如果Post数量是从数据库中取得的,那么初始化为1是不正确的选择,此时可以通过静态代码块在类加载时执行获取数据库中的值
    // 加载类的时候会先执行这里的代码
    static {
        count = 100; //这里假设100是从数据库中获取Post的数量
    }
}

// cat Point.java
public class Point<T> {
    private T x;
    private T y;

    public T getX() {
        return x;
    }

    public void setX(T x) {
        this.x = x;
    }

    public T getY() {
        return y;
    }

    public void setY(T y) {
        this.y = y;
    }
}

// cat Test.java
public class Test{
    public static void main(String[] args){

        // 坐标为int类型,把int类型的包装类Integer作为参数传入泛型类中
        Point<Integer> point1 = new Point<Integer>();
        point1.setX(1);
        point1.setY(1);

        // 坐标为double类型,把double类型的包装类Double作为参数传入泛型类中
        Point<Double> point2 = new Point<Double>();
        point2.setX(3.456);
        point2.setY(4.789);
    }
}

public class Triple<A, B, C> {
    private A a;
    private B b;
    private C c;
}

public class Printer {
    public static <T> void printArray(T[] objects) {
        if (objects != null) {
            for(T element : objects){
                System.out.printf("%s",element);
            }
        }
    }

    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3, 4, 5};
        Character[] charArray = {'A', 'B', 'C', 'D'};

        printArray(intArray);
        printArray(charArray);
    }
}

// cat Graph.java
class Graph {
    String name;
    public Graph(){}
    public Graph(String name) {
        this.name = name;
    }
    public void show() {
        System.out.println("I'm a graph");
    }
}

// cat Rectangle.java
class Rectangle extends Graph {
    int width;
    int height;

    public Rectangle(){
        // this表示对当前对象的引用
        // 子类构造函数中,一般第一条语句是`super();`,表示调用父类构造函数
        // 构造函数的第一语句既不是this()也不是super()时,就会隐含的调用super()
        super();
    }

    public Rectangle(String name) {
        super(name);
    }

    public Rectangle(int width, int height,String name) {
        // this表示对当前对象的引用
        this(name);
        System.out.println("My width is:" + width + "my height is :"+ height);
    }

    public void show() {
        // Retangle就覆盖了Graph的show方法,同时在show方法中通过super.show();调用了父类的show方法
        super.show();
        System.out.println("at the same time I'm a Rectangle");
    }
}

abstract class Graph {
    String name;
    public Graph(){}
    public Graph(String name) {
        this.name = name;
    }
    public void show() {
        System.out.println("I'm a graph");
    }
}

abstract class Graph {
    String name;
    public Graph(){}
    public Graph(String name) {
        this.name = name;
    }
    public void show() {
        System.out.println("I'm a graph");
    }
    public abstract double area();
}

// 这时Rectangle类就必须给出area()方法的实现,否则它自己也必须用abstract修饰

class Rectangle extends Graph{
    double width;
    double height;
    public double area() {
        return width * height;
    }
}

interface Animal {
    static final int TIMES_OF_EATING = 3;
    void eat();
    void sleep();
}
// 接口可以继承其他的接口
interface TerrestrialAnimal extends Animal {
    void run();
}

class Cat implements Animal {
    public void eat() {
        System.out.println("eat");
    }
    public void sleep() {
        System.out.println("sleep");
    }
}

public class HelloWorld {
    public static void main(String[] args) {
        // try代码有异常 异常点以后代码不执行 直接执行catch以及之后的代码
        try {
            int x = 5 / 0;
            System.out.println(x);
        } catch (Exception e) {
            // 展开错误栈
            e.printStackTrace();
        }
        System.out.println("program is still running here!");
    }
}

public class HelloWorld {

    public static void main(String[] args) {
        try {
            foo();
            bar();
        // 分别按照顺序查看多个异常,当有一个异常匹配中的时候就按照顺序检查异常
        } catch (BlogAppException e) {
            e.printStackTrace();
        } catch (ArithmeticException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("program is still running here!");
    }
}

public class HelloWorld {

    public static void main(String[] args) {
        try {
            foo();
            bar();
        } catch (BlogAppException e) {
            e.printStackTrace();
            return;
        } catch (ArithmeticException e) {
            e.printStackTrace();
            return; // 即使这里return了,依然会执行finally中的语句
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("programe will run `finally` code block!");
        }
        System.out.println("program is still running here!");
    }
}

public class HelloWorld {
    // throws关键字将方法异常交给其调用者
    // throws的异常应该是更加具体粒度更加细的
    private static void foo() throws Exception {
        int x = 5 / 0;
        System.out.println(x);
    }

    public static void main(String[] args) {
        try {
            foo();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("program is still running here!");
    }
}

// cat BlogAppException.java
public class BlogAppException extends Exception {

    private static final long serialVersionUID = 1L;

    private String command;// 可以给自定义异常增加成员变量,用以保存额外的异常信息

    public BlogAppException(String command) {
        this.command = command;
    }

    public String toString(){
        return "Exception happened when executing command " + command;
    }
}

// cat HelloWorld.java
public class HelloWorld {

    private static void bar() throws BlogAppException {
        System.out.println("let's assume BlogAppException happened when executing `create` command");
        // 为了演示,这里我们假设执行create命令时,抛出了异常
        throw new BlogAppException("create");
    }

    private static void foo() throws ArithmeticException {
        int x = 5 / 0;
        System.out.println(x);
    }

    public static void main(String[] args) {
        try {
            foo();
            bar();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("program is still running here!");
    }
}

// cat Post.java
public class Post {
    String title; // 成员变量
    String content; // 成员变量
    // 成员方法
    void print() {
        System.out.println(title);
        System.out.println(content);
    }
}

// cat HelloWorld.java
public class HelloWorld {
    public static void main(String[] args) {
        Post post = new Post();    // 创建博客对象
        post.title = "title";      // 对象属性赋值
        post.content = "content";  // 对象属性赋值
        post.print();              // 调用对象方法
    }
}

// 一般文件 如 archive.tar.gz
String extension = "";
int i = fileName.lastIndexOf('.');
// 保证没有扩展名的文件不会报错
if (i > 0) {
    extension = fileName.substring(i + 1);
}

// 特殊文件 如 /path/to.a/file
String extension = "";
int i = fileName.lastIndexOf('.');
int p = Math.max(fileName.lastIndexOf('/'), fileName.lastIndexOf('\\'));
if (i > p) {
    extension = fileName.substring(i + 1);
}

// 可以在报错提醒之前使用`@SuppressWarnings("unchecked")`解决
@SuppressWarnings("unchecked")
Map<String, Number> map = getMap();
for (String s : map.keySet());
for (Number n : map.values());