4 万字超强总结！Java 这些必备基础知识不可少

src
 main
  java
   com
    jourwon
     prop
      PropertiesTest
  resources
   config.properties
   prop.properties

username=root
password=123456

public static void main(String[] args) throws IOException {
    Properties properties = new Properties();
    OutputStream output = null;
    try {
        output = new FileOutputStream("src/main/resources/config.properties");
        properties.setProperty("username", "root");
        properties.setProperty("password", "123456");

        // 保存键值对到文件中
        properties.store(output, "JourWon modify");

    } catch (IOException io) {
        io.printStackTrace();
    } finally {
        if (output != null) {
            try {
                output.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

#JourWon modify
#Mon Sep 09 14:23:44 CST 2019
password=123456
username=root

public static void main(String[] args) throws IOException {
    // PropertiesTest.getPath1();
    // PropertiesTest.getPath2();
    // PropertiesTest.getPath3();
    // PropertiesTest.getPath4();
    // PropertiesTest.getPath5();
    PropertiesTest.getPath6();
}

/**
     * 一、 使用java.util.Properties类的load(InputStream in)方法加载properties文件
     * 主要是需要加上src这个文件夹名。路径配置需要精确到绝对地址级别
     *
     * @return
     */
public static void getPath1() throws IOException {
    InputStream in = new BufferedInputStream(new FileInputStream(
        new File("src/main/resources/prop.properties")));

    printKeyValue(in);

}

/**
     * 二、 使用java.util.ResourceBundle类的getBundle()方法
     * 注意：这个getBundle()方法的参数只能写成包路径+properties文件名，注意不需要带上后缀名。
     *
     * @return
     */
public static void getPath2() {
    ResourceBundle rb = ResourceBundle
        .getBundle("prop");

    printKeyValueRb(rb);
}

/**
     * 三、 使用java.util.PropertyResourceBundle类的构造函数
     *
     * @return
     */
public static void getPath3() throws IOException {
    InputStream in = new BufferedInputStream(new FileInputStream("src/main/resources/prop.properties"));
    ResourceBundle rb = new PropertyResourceBundle(in);

    printKeyValueRb(rb);
}

/**
     * 四、 使用class变量的getResourceAsStream()方法
     * 注意：getResourceAsStream()方法的参数按格式写到包路径+properties文件名+.后缀
     *
     * @return
     */
public static void getPath4() throws IOException {
    InputStream in = PropertiesTest.class
        .getResourceAsStream("/prop.properties");

    printKeyValue(in);
}

/**
     * 五、
     * 使用class.getClassLoader()所得到的java.lang.ClassLoader的
     * getResourceAsStream()方法
     * getResourceAsStream(name)方法的参数必须是包路径+文件名+.后缀
     * 否则会报空指针异常
     *
     * @return
     */
public static void getPath5() throws IOException {
    InputStream in = PropertiesTest.class.getClassLoader()
        .getResourceAsStream("./././prop.properties");

    printKeyValue(in);
}

/**
     * 六、 使用java.lang.ClassLoader类的getSystemResourceAsStream()静态方法
     * getSystemResourceAsStream()方法的参数格式也是有固定要求的
     *
     * @return
     */
public static void getPath6() throws IOException {
    InputStream in = ClassLoader
        .getSystemResourceAsStream("./././prop.properties");

    printKeyValue(in);
}


/**
     * 单独抽取的方法，用户检测能否正确操纵Properties
     *
     * @param inputStream
     * @throws IOException
     */
public static void printKeyValue(InputStream inputStream) throws IOException {
    Properties properties = new Properties();
    properties.load(inputStream);
    Set<Object> keys = properties.keySet();
    for (Object key : keys) {
        System.out.println(key + " = " + properties.get(key));
    }

    if (inputStream != null) {
        inputStream.close();
    }
}

public static void printKeyValueRb(ResourceBundle rb) {
    Set<String> keys = rb.keySet();
    for (String key : keys) {
        System.out.println(key + " = " + rb.getString(key));

    }
}

password = 123456
username = root

/**
  * 输出properties的key和value
  */
public static void printProp(Properties properties) {
    System.out.println("---------（方式一）------------");
    for (String key : properties.stringPropertyNames()) {
        System.out.println(key + "=" + properties.getProperty(key));
    }

    System.out.println("---------（方式二）------------");
    //返回属性key的集合
    Set<Object> keys = properties.keySet();
    for (Object key : keys) {
        System.out.println(key.toString() + "=" + properties.get(key));
    }

    System.out.println("---------（方式三）------------");
    Set<Map.Entry<Object, Object>> entrySet = properties.entrySet();
    //返回的属性键值对实体
    for (Map.Entry<Object, Object> entry : entrySet) {
        System.out.println(entry.getKey() + "=" + entry.getValue());
    }

    System.out.println("---------（方式四）------------");
    Enumeration<?> e = properties.propertyNames();
    while (e.hasMoreElements()) {
        String key = (String) e.nextElement();
        String value = properties.getProperty(key);
        System.out.println(key + "=" + value);
    }
}

name1: zhangsan
name2: 'zhangsan \n lisi'
name3: "zhangsan \n lisi"
age: 18
flag: true

date: 2019/01/01

people:
    name: zhangsan
    age: 20

people: {name:zhangsan,age: 20}

pets:
    - dog
    - pig
    - cat

pets: [dog,pig,cat]

peoples:
    - name: zhangsan
      age: 22
    - name: lisi
      age: 20
    - {name: wangwu,age: 18}

public class Person {

    private String lastName;
    private Integer age;
    private Boolean boss;

    private Date birth;
    private Map<String,Object> maps;
    private List<Dog> lists;
    private Dog dog;
    private String[] arr;
｝
public class Dog {
    private String name;
    private Integer age;
}

person:
  boss: false
  maps:
    k1: v1
    k2: 14
  lists:
    - name: d1
      age: 2
    - name: d2
      age: 3
    - {name: d3,age: 4}
  birth: 2017/12/15
  dog:
    name: p_dog
    age: 15
  age: 13
  last-name: 张三
  arr: [s1,s2,s3]

server:
  port: 8081
spring:
  profiles:
    active: prod #激活对应的文档块

---
server:
  port: 8083
spring:
  profiles: dev #指定属于哪个环境


---

server:
  port: 8084
spring:
  profiles: prod  #指定属于哪个环境

一个无序键值对的集合，以"{“开始，同时以”}“结束，键值对之间以”:“相隔，不同的键值对之间以”,"相隔，举例

{
    "key1" : 1,
    "key2" : "string"
}

[ "Google", "Runoob", "Taobao" ]

{
    "name":"网站",
    "money":3.22,
    "status":0,
    "valid":true,
    "address":null,
    "sites": [
        { "name":"Google", "info":[ "Android", "Google 搜索", "Google 翻译" ] },
        { "name":"Runoob", "info":[ "菜鸟教程", "菜鸟工具", "菜鸟微信" ] },
        { "name":"Taobao", "info":[ "淘宝", "网购" ] }
    ]
}

<?xml version="1.0" encoding="UTF-8"?>
<persons>
    <person id="p001">
        <name>张三</name>
    </person>
    <person id="p002">
        <name>李四</name>
    </person>
</persons>

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5">
    <servlet>
        <servlet-name>HelloMyServlet</servlet-name>
        <servlet-class>com.jourwon.HelloMyServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HelloMyServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
</web-app>

<?xml version="1.0" encoding="UTF-8"?>

<servlet>

<web-app version="2.5">

<![CDATA[
    任意内容
]]>

<?xml-stylesheet type="text/css" href="a.css"?>

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5">
    <servlet>
        <servlet-name>HelloMyServlet</servlet-name>
        <servlet-class>com.jourwon.HelloMyServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HelloMyServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
</web-app>

<dependency>
    <groupId>org.dom4j</groupId>
    <artifactId>dom4j</artifactId>
    <version>2.1.1</version>
</dependency>

public class Dome4jTest {

    public static void main(String[] args) throws DocumentException {
        // 1 创建核心对象（new 方式）
        SAXReader saxReader = new SAXReader();
        //2 加载xml文档 获得dom树（核心对象调用read读取xml文件）
        Document doc = saxReader.read("E:\\IdeaProjects\\demo1\\src\\main\\resources\\demo.xml");
        //3 获得根元素（文档对象下面就是根元素）
        Element root = doc.getRootElement();
        //4 获得子元素（根节点下所有子元素）
        List<Element> list = root.elements();

        for (Element e : list) {
            // elementText("标签名") 获得指定名称元素的文本值 （指定标签的文本值）
            // getName() 获得当前元素名
            if ("servlet".equals(e.getName())) {
                System.out.println(e.elementText("servlet-name"));
                System.out.println(e.getName());
            }

        }
    }

}

HelloMyServlet
servlet

格式:
<!DOCTYPE 根元素名 [dtd语法]>

格式:
<!DOCTYPE 根元素名 SYSTEM "约束文件的位置">
例如:
<!DOCTYPE web-app SYSTEM "web-app_2_3.dtd">

<?xml version="1.0" encoding="UTF-8" ?>
<!ELEMENT web-app (servlet*, servlet-mapping* , welcome-file-list?) >
<!ELEMENT servlet (servlet-name, description?, (servlet-class|jsp-file))> 
<!ELEMENT servlet-mapping (servlet-name, url-pattern) >
<!ELEMENT servlet-name (#PCDATA)>
<!ELEMENT servlet-class (#PCDATA)>
<!ELEMENT url-pattern (#PCDATA)>
<!ELEMENT welcome-file-list (we1come-fi1e+)> 
<!ELEMENT welcome-file (#PCDATA)>
<!ATTLIST web-app version CDATA #IMPLIED>

格式:
<!DOCTYPE 根元素名 PUBLIC "约束文件的名称" "约束文件的位置">
如mybatis中mapper的约束
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >

标签（元素）语法：
<!Element 元素名称 数据类型|包含内容>

数据类型:#PCDATA:普通文本 使用的时候一般用()引起来

功能：能出现那些标签，以及出现顺序

包含内容:该元素下可以出现哪些元素 用()引起来

符号:
            *   出现任意次
            ?   出现1次或者0次
            +   出现至少1次
            |   或者
            ()  分组
            ,   顺序（元素出现先后顺序，按照都好标记顺序出现）

栗子如下：（上图约束图中的代码）
<!ELEMENT web-app (servlet*,servlet-mapping* , welcome-file-list?) >
<!ELEMENT servlet-name (#PCDATA)>

ps：元素名就是xml中能够出现的元素标签名
属相的约束语法：
                
    属性:
        格式:
            <!ATTLIST 元素名 属性名 属性类型 属性是否必须出现>
        属性类型:
            ID:唯一
            CDATA:普通文本
        属性是否必须出现
            REQUIRED:必须出现
            IMPLIED:可以不出现


例如：
<!ATTLIST web-app version CDATA #IMPLIED>

xml和schema的关联.
        格式:
            <根标签 xmlns="..." ...>
            <根标签 xmlns:别名="..." ...>
    名称空间:
        关联约束文件
        规定元素是来源于那个约束文件的
    例如:
        一个约束文件中规定 table(表格)  表格有属性 row和col
        还有一个约束文件规定 table(桌子) 桌子有属性 width和height
        
        在同一个xml中万一我把两个约束文件都导入了,
            在xml中我写一个table,这个table有什么属性????
        我们为了避免这种情况的发生,可以给其中的一个约束起个别名
        使用的时候若是没有加别名那就代表是来自于没有别名的约束文件
            例如 table(表格) 给他起个别名  xmlns:a="..."
            在案例中使用 a:table 代表的是表格
            若在案例中直接使用 table 代表的是桌子
        
     ps:在一个xml文件中只能有一个不起别名;
注意:
    schema约束本身也是xml文件.

<?xml version="1.0" encoding="UTF-8"?>
<!-- 
    
    模拟servlet2.5规范，如果开发人员需要在xml使用当前Schema约束，必须包括指定命名空间。
    格式如下：
    <web-app xmlns="http://www.example.org/web-app_2_5" 
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://www.example.org/web-app_2_5 web-app_2_5.xsd"
            version="2.5">
-->
<xsd:schema xmlns="http://www.w3.org/2001/XMLSchema" 
    targetNamespace="http://www.example.org/web-app_2_5"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:tns="http://www.example.org/web-app_2_5" 
    elementFormDefault="qualified">
    
    <xsd:element name="web-app">
        <xsd:complexType>
            <xsd:choice minOccurs="0" maxOccurs="unbounded">
                <xsd:element name="servlet">
                    <xsd:complexType>
                        <xsd:sequence>
                            <xsd:element name="servlet-name"></xsd:element>
                            <xsd:element name="servlet-class"></xsd:element>
                        </xsd:sequence>
                    </xsd:complexType>
                </xsd:element>
                <xsd:element name="servlet-mapping">
                    <xsd:complexType>
                        <xsd:sequence>
                            <xsd:element name="servlet-name"></xsd:element>
                            <xsd:element name="url-pattern"></xsd:element>
                        </xsd:sequence>
                    </xsd:complexType>
                </xsd:element>
                <xsd:element name="welcome-file-list">
                    <xsd:complexType>
                        <xsd:sequence>
                            <xsd:element name="welcome-file" maxOccurs="unbounded"></xsd:element>
                        </xsd:sequence>
                    </xsd:complexType>
                </xsd:element>
            </xsd:choice>
            <xsd:attribute name="version" type="double" use="optional"></xsd:attribute>
        </xsd:complexType>
    </xsd:element>
</xsd:schema>

The common interface extended by all annotation types.

@Override
public String toString() {
    return "Hello Annotation";
}

@Target(ElementType.TYPE) 
@Retention(RetentionPolicy.RUNTIME)
public @interface Persons {
 Person[] value();
}

@Repeatable(Persons.class)
public @interface Person{
 String role() default "";
}

@Person(role="CEO")
@Person(role="husband")
@Person(role="father")
@Person(role="son")
public   class Man {
 String name="";
}

public static void main(String[] args) {
    Annotation[] annotations = Man.class.getAnnotations();  
    System.out.println(annotations.length);
    Persons p1=(Persons) annotations[0];
    for(Person t:p1.value()){
     System.out.println(t.role());
    }
}

1
CEO
husband
father
son

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation{
    
    int id();
    
    String msg();

}

@TestAnnotation(id=3, msg="hello annotation")
public class Test {

}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface IntegerVaule{
   int value() default 0;
   String name() default "";
}

public class QuicklyWay {
   
   @IntegerVaule(20)
   public int age;
   
   @IntegerVaule(value = 10000, name = "MONEY")
   public int money;
 
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnTargetType {

    /**
     * 定义注解的一个元素 并给定默认值
     * @return
     */
    String value() default "定义在类接口枚举类上的注解元素value的默认值";

}

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnTargetMethod {

    /**
     * 定义注解的一个元素 并给定默认值
     * @return
     */
    String value() default "定义在方法上的注解元素value的默认值";

}

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnTargetField {

    /**
     * 定义注解的一个元素 并给定默认值
     * @return
     */
    String value() default "定义在字段上的注解元素value的默认值";

}

@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnTargetParameter {

    /**
     * 定义注解的一个元素 并给定默认值
     * @return
     */
    String value() default "定义在参数上的注解元素value的默认值";

}

@MyAnTargetType
public class AnnotationTest {

    @MyAnTargetField
    private String field = "我是字段";

    @MyAnTargetMethod("测试方法")
    public void test(@MyAnTargetParameter String args) {
        System.out.println("参数值 === " + args);
    }

    public static void main(String[] args) {
        // 获取类上的注解MyAnTargetType
        MyAnTargetType t = AnnotationTest.class.getAnnotation(MyAnTargetType.class);
        System.out.println("类上的注解值 === " + t.value());
        MyAnTargetMethod tm = null;
        try {
            // 根据反射获取AnnotationTest类上的test方法
            Method method = AnnotationTest.class.getDeclaredMethod("test", String.class);
            // 获取方法上的注解MyAnTargetMethod
            tm = method.getAnnotation(MyAnTargetMethod.class);
            System.out.println("方法上的注解值 === " + tm.value());
            // 获取方法上的所有参数注解  循环所有注解找到MyAnTargetParameter注解
            Annotation[][] annotations = method.getParameterAnnotations();
            for (Annotation[] tt : annotations) {
                for (Annotation t1 : tt) {
                    if (t1 instanceof MyAnTargetParameter) {
                        System.out.println("参数上的注解值 === " + ((MyAnTargetParameter) t1).value());
                    }
                }
            }
            method.invoke(new AnnotationTest(), "改变默认参数");
            // 获取AnnotationTest类上字段field的注解MyAnTargetField
            MyAnTargetField fieldAn = AnnotationTest.class.getDeclaredField("field").getAnnotation(MyAnTargetField.class);
            System.out.println("字段上的注解值 === " + fieldAn.value());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

类上的注解值 === 定义在类接口枚举类上的注解元素value的默认值
方法上的注解值 === 测试方法
参数上的注解值 === 定义在参数上的注解元素value的默认值
参数值 === 改变默认参数
字段上的注解值 === 定义在字段上的注解元素value的默认值

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface SysLog {

    /**
     * 操作说明
     */
    String value() default "";

}

@Aspect
@Component
public class SysLogAspect {

    @Autowired
    private SysLogMapper sysLogMapper;

    @Pointcut("@annotation(com.jourwon.annotation.SysLog)")
    public void logPointCut() {

    }

    @Around("logPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        long beginTime = System.currentTimeMillis();
        //执行方法
        Object result = point.proceed();
        //执行时长(毫秒)
        long time = System.currentTimeMillis() - beginTime;

        //保存日志
        saveSysLog(point, time);

        return result;
    }

    private void saveSysLog(ProceedingJoinPoint joinPoint, long time) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();

        SysLogEntity sysLog = new SysLogEntity();
        SysLog syslog = method.getAnnotation(SysLog.class);
        if (syslog != null) {
            //注解上的描述
            sysLog.setOperation(syslog.value());
        }

        //保存系统日志
        sysLogMapper.insertSelective(sysLog);
    }

}

@SysLog("保存用户")
@PostMapping("/save")
public Result save(@RequestBody SysUserEntity user) {
    sysUserService.save(user);

    return Result.ok();
}

public class Book{
    private final static String TAG = "BookTag";

    private String name;
    private String author;

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                '}';
    }

    public Book() {
    }

    private Book(String name, String author) {
        this.name = name;
        this.author = author;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    private String declaredMethod(int index) {
        String string = null;
        switch (index) {
            case 0:
                string = "I am declaredMethod 0 !";
                break;
            case 1:
                string = "I am declaredMethod 1 !";
                break;
            default:
                string = "I am declaredMethod -1 !";
        }

        return string;
    }
}

Book book1 = new Book();
Class<? extends Book> book1Class = book1.getClass();

@Test
public void getClz() {
    try {
        // 方法一，使用 Class.forName 静态方法
        Class<?> classBook = Class.forName("com.jourwon.reflect.Book");

        // 方法二：直接通过 类名.class 的方式得到
        Class clz = Book.class;

        // 方法三：使用类对象的 getClass() 方法。
        Book book1 = new Book();
        Class<? extends Book> book1Class = book1.getClass();

        System.out.println(classBook == clz);
        System.out.println(classBook == book1Class);

    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

true
true

public class ReflectClass {

    private static final Logger log = LoggerFactory.getLogger(ReflectClass.class);

    // 创建对象
    @Test
    public void reflectNewInstance() {
        try {
            Class<?> classBook = Class.forName("com.jourwon.reflect.Book");

            Object objectBook = classBook.newInstance();
            Book book = (Book) objectBook;
            book.setName("Java高级特性-反射-创建对象");
            book.setAuthor("JourWon");
            log.info(book.toString());

        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    // 反射私有的构造方法
    @Test
    public void reflectPrivateConstructor() {
        try {
            Class<?> classBook = Class.forName("com.jourwon.reflect.Book");
            Constructor<?> declaredConstructorBook = classBook.getDeclaredConstructor(String.class, String.class);
            // 暴力反射
            declaredConstructorBook.setAccessible(true);
            Object objectBook = declaredConstructorBook.newInstance("Java高级特性-反射-反射私有的构造方法", "JourWon");
            Book book = (Book) objectBook;
            log.info(book.toString());
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    // 反射私有属性
    @Test
    public void reflectPrivateField() {
        try {
            Class<?> classBook = Class.forName("com.jourwon.reflect.Book");
            Object objectBook = classBook.newInstance();
            Field fieldTag = classBook.getDeclaredField("TAG");
            fieldTag.setAccessible(true);
            String tag = (String) fieldTag.get(objectBook);
            log.info(tag);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }


    // 反射私有方法
    @Test
    public void reflectPrivateMethod() {
        try {
            Class<?> classBook = Class.forName("com.jourwon.reflect.Book");
            Method methodBook = classBook.getDeclaredMethod("declaredMethod", int.class);
            methodBook.setAccessible(true);
            Object objectBook = classBook.newInstance();
            String string = (String) methodBook.invoke(objectBook, 0);

            ReflectClass.

            log.info(string);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }


}

[main] INFO com.jourwon.reflect.ReflectClass - Book{name='Java高级特性-反射-创建对象', author='JourWon'}

[main] INFO com.jourwon.reflect.ReflectClass - Book{name='Java高级特性-反射-反射私有的构造方法', author='JourWon'}

[main] INFO com.jourwon.reflect.ReflectClass - BookTag

[main] INFO com.jourwon.reflect.ReflectClass - I am declaredMethod 0 ! 

/*
 * 顺序结构：从上往下，依次执行
 */
public class OrderDemo {
 public static void main(String[] args) {
  System.out.println("开始");
  System.out.println("语句A");
  System.out.println("语句B");
  System.out.println("语句C");
  System.out.println("结束");
 }
}

if(条件表达式){
执行的代码块；
}

public class IfDemo {
 public static void main(String[] args) {
  System.out.println("开始");
  // 定义两个变量
  int a = 10;
  int b = 20;

  if (a == b) {
   System.out.println("a等于b");
  }
 
  int c = 10;
  if (a == c) {
   System.out.println("a等于c");
  }
 
  System.out.println("结束");
 }
}

if(条件表达式){
执行的代码块;
}else{
执行的代码块；
}

public class IfDemo2 {
 public static void main(String[] args) {
  System.out.println("开始");
  // 判断给定的数据是奇数还是偶数
  // 定义变量
 int a = 100;
  // 给a重新赋值
 a = 99;

 if (a % 2 == 0) {
  System.out.println("a是偶数");
 } else {
  System.out.println("a是奇数");
 }
 
  System.out.println("结束");
 }
}

if(条件表达式){
执行的代码块;
}else if(条件表达式){
执行的代码块;
}…(此处省略N个else if)
else{
执行代码块;
}

public class IfDemo3 {
 public static void main(String[] args) {
  // x和y的关系满足如下：
  // x>=3 y = 2x + 1;
  // -1<=x<3 y = 2x;
  // x<=-1 y = 2x – 1;
  // 根据给定的x的值，计算出y的值并输出。

  // 定义变量
  int x = 5;
  
  /*
  int y;
  if (x >= 3) {
   y = 2 * x + 1;
  } else if (x >= -1 && x < 3) {
   y = 2 * x;
  } else if (x <= -1) {
   y = 2 * x - 1;
  }else {
   y = 0;
  }
  */
  
  int y = 0;
  if (x >= 3) {
   y = 2 * x + 1;
  } else if (x >= -1 && x < 3) {
   y = 2 * x;
  } else if (x <= -1) {
   y = 2 * x - 1;
  }
  
  System.out.println("y的值是："+y);
 }
}

public class SwitchDemo {
 public static void main(String[] args) {
  //创建键盘录入对象
  Scanner sc = new Scanner(System.in);
  
  //接收数据
  System.out.println("请输入一个数字(1-7)：");
  int weekday = sc.nextInt();
  
  //switch语句实现选择
  switch(weekday) {
  case 1:
   System.out.println("星期一");
   break;
  case 2:
   System.out.println("星期二");
   break;
  case 3:
   System.out.println("星期三");
   break;
  case 4:
   System.out.println("星期四");
   break;
  case 5:
   System.out.println("星期五");
   break;
  case 6:
   System.out.println("星期六");
   break;
  case 7:
   System.out.println("星期日");
   break;
  default:
   System.out.println("你输入的数字有误");
   break;
  }
 }
}

for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}

public class ForDemo {
 public static void main(String[] args) {
  //原始写法
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("-------------------------");
  

  //用循环改进
  for(int x=1; x<=10; x++) {
   System.out.println("HelloWorld");
  }
 }
}

for (声明语句 : 表达式) {
  //代码句子
}

public class Test {
    public static void main(String args[]) {
        int [] numbers = {10, 20, 30, 40, 50};
        
        for ( int x : numbers ) {
            System.out.print( x );
            System.out.print(",");
        }
        
        System.out.print();
        String [] names = {"James", "Larry", "Tom", "Lacy"};
        
        for ( String name : names ) {
            System.out.print( name );
            System.out.print(",");
        }
    }
}

while(判断条件语句) {
循环体语句;
}

初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}

public class WhileDemo {
 public static void main(String[] args) {
  //输出10次HelloWorld
  /*
  for(int x=1; x<=10; x++) {
   System.out.println("HellloWorld");
  }
  */
  
  //while循环实现
  int x=1;
  while(x<=10) {
   System.out.println("HellloWorld");
   x++;
  }
 }
}

do {
循环体语句;
}while((判断条件语句);

初始化语句;
do {
循环体语句;
控制条件语句;
} while((判断条件语句);

public class DoWhileDemo {
 public static void main(String[] args) {
  //输出10次 HelloWorld
  /*
  for(int x=1; x<=10; x++) {
   System.out.println("HelloWorld");
  }
  */
  

  //do...while改写
  int x=1;
  do {
   System.out.println("HelloWorld");
   x++;
  }while(x<=10);
 }
}

/*
 * break:中断的意思
 * 使用场景：
 *   A:switch语句中
 *   B:循环中
 * 注意：
 *   离开使用场景是没有意义的。
 * 作用：
 *   跳出循环，让循环提前结束
 */
public class BreakDemo {
 public static void main(String[] args) {
  //break;
  
  for(int x=1; x<=10; x++) {
   if(x == 3) {
    break;
   }
   System.out.println("HelloWorld");
  }
 }
}

```java
/*
 * continue:继续的意思
 * 使用场景：
 *   循环中
 * 注意：
 *   离开使用场景是没有意义的
 * 作用：
 *   结束一次循环，继续下一次的循环
 * 区别：
 *   break:退出循环
 *   continue:结束一次循环，继续下一次的循环
 */
public class ContinueDemo {
 public static void main(String[] args) {
  //continue;
  
  for(int x=1; x<=10; x++) {
   if(x == 3) {
    //break;
    continue;
   }
   System.out.println("HelloWorld");
  }
 }
}

public class ReturnDemo {
 public static void main(String[] args) {
  getStr();
 }

 public String getStr() {
        return "Hello";
    }

}

a + b
3.14 + a
(x + y) * z + 100
boolean b= i < 10 && (i%10 != 0)

+ - + - * / % ++ -- +

= += -= *= /= %=

= += -= *= /= %=

基本的赋值运算符：=

扩展的赋值运算符：+=,-=,*=,/=,%=
+=: a+=20;相当于a = (a的数据类型)(a + 20);

& | ^ ! && ||

public class Variable{
    // 类变量
    static int allClicks=0;    
     // 实例变量
    String str="hello world";  
    public void method(){
    // 局部变量
        int i =0;  
    }
}

1B= 8b
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB