java基础一：基础概念、面向对象

java基础一：基础概念、面向对象
目录

1.基础概念

2.IDEA 开发工具

2.1 JDK环境配置

2.2 注释和变量

2.3 标识符

2.4 数据类型

2.5 算术运算符

2.6 赋值运算符

2.7 关系运算符

2.8 逻辑运算符

2.9 三元运算符

2.10 流程控制

3. 面向对象

3.1类和对象

3.2 静态 static

3.3 package 包

3.4 import 导入

3.5 构造函数

3.5 继承 extends

3.6 多态

3.7 方法重载

3.8 方法重写

3.9 递归

3.10 访问权限

3.11 内部类

3.12 单例模式

3.13 final 关键字

3.14 抽象 abstract

3.15 接口 interface

3.16 枚举 enum

3.17 匿名类

3.18 bean 规范

3.19 作用域

3.20 总结 java 关键字

1.基础概念
- JVM：将代码编译成字节码，java虚拟机
- JDK：开发工具包，是java核心
- JRK：程序的运行环境
- JDK>JRE>JVM
2.IDEA 开发工具

2.1 JDK环境配置

cmd——环境变量——系统变量

1. 新建——JAVA_HOME——jdk安装目录（jre.1.8.0）

2. 编辑——PATH变量——新增——%JAVA_HOME%\bin

3. 编辑环境变量——C:\Program Files (x86)\Java\jre1.8.0_291\bin

4. 新建——CLASSPATH变量

cmd 输入javac 则环境配置成功

2.2 注释和变量

TODO 标识符：注释标识符，可快速调整到代码内容

ctrl + D ：复制到当前行

变量定义：改变向量的存储

变量声明、变量赋值、变量使用

注意：在使用变量前要先声明
```
package chapter01;
 
public class Java02_variable {
    public static void main(String[] args) {
        // TODO 变量
        // 可以改变向量的存储
        // 1.变量声明
        String name;
        // 2.变量赋值
        name = "lisa";
        // 3.变量使用
        System.out.println(name);
        //声明赋值:
        String age = "18";
    }
}
```
2.3 标识符

定义：标识数据的符号，主要用去取名，如 String name = "lisa"; 中的name

命名规则
- 由字母、数字（不能开头）、特殊字符（只用_、$）组成
- 在{ }内标识符不能重复
- 标识符区分大小写
- 已经定义好的标识符叫关键字、保留字；如Public、class
- 用驼峰命名法，如userName
- 没有长度限制
2.4 数据类型

基本数据类型-数值型-整数
- bit，比特，数据运算的最小单位，1位
- byte，字节，数据的最小单位，1byte=8bite，8位
- short，16位
- int，32位
- long，64位
基本数据类型-数值型-浮点型
- float：单精度浮点，以F/f结尾，如1.2f
- double：双精度浮点，如1.1，默认
基本数据类型-字符型
- char c ='v'
基本数据类型-布尔型
- boolean b = true/false
数据类型转换

小的类型可以自动转换大的数据类型

bit > byte > short > int > long > float > double

大的数据类型需要(）小括号强制转换数据类型

如double d = 1.2,int a = int (d)

引用数据类型

定义：可以被引用的数据类型

2.5 算术运算符

运算符定义：参与数据运算的符号，java定义，不能自定义

表达式：运算符和变量组合一起

一元运算符：一个变量参与计算，如 a ++

++a ，a 在前面先加1，++a 后计算

a++，a 在a++后面加一，a后计算

二元运算符：二个变量参与计算，如 a + b

算术表达式：是有结果的，如1+5=6，结果是数据类型最大的

如1/2=0，因为1 2 都是int型，结果也是int型，最小使用类型是int

2.6 赋值运算符

= ：就是赋值运算符

将右边的变量赋值给左边的变量

如： int age = 18

注意：需要考虑数据类型的关系，小的数据类型赋值给大的数据类型

复合运算符：+=、-=、*=、%=

a+=1相当于a=a+1

使用复合运算符，数据类型不会改变

2.7 关系运算符

定义：比较数据

关系运算符有：== 、!=、>、<、>=、<=等

2.8 逻辑运算符

定义：用于描述多个表达式之间的关系

语法结构：（条件表达式1）逻辑表达式（条件表达式）

结果：布尔类型，true\false

与运算：&一假为假

或运算，|一真为真

短路与运算：&&，根据第一个条件的结果，是否执行第二个，如 false && false，第二个不用执行

短路或运算：||，根据第一个的结果，是否执行第二个，第一个为真不执行第二个

非运算符：！，相反运算符

2.9 三元运算符

定义：三个变量参与运算的运算符

语法结构：变量 = 条件表达式1 ？条件表达式2：条件表达式3

当1为true，变量等于 2，为false等于3

2.10 流程控制

定义：计算机在执行代码工程中，对指令代码执行顺序
- 顺序执行：按照代码出现的先后顺序
- 分支执行：单分支 if(){}、双分支 if...else..、多分支if..else if..else..、特殊分支switch..case
- 重复执行（循环）：while、do...while、for
- 跳出循环：break（跳出）
- 跳出本次循环：continue（跳过）
3. 面向对象

3.1类和对象

定义：分析问题时，以问题涉及到的事或者物为中心的分析方式

类：类就是归纳和整理，如动物是一个类

类名命名规范首字母大写

对象：具体的事物，如猫，类的实例化， new Cat()

new 是一个关键字，创建一个具体对象，使用一次创建一次

一般new创建的对象会赋值变量，方便重复使用

变量的类型就是对象说的类型，Cat c = new Cat(),Cat是引用数据类型

对象是将内存地址赋值给变量，所以变量是引用了内存中的变量，所以叫引用变量

特殊对象：没有引用的对象，String user = null

类的语法结构：
```
package chapter01;
 
public class Java04_object {
    public static void main(String[] args) {
        // TODO 面向对象
        // 创建类
        class Cat {
            // 属性
            int age = 3;
            String name = "喵喵";
            // 方法
            // 方法声明
            void say(){
                System.out.println("miao~");
            }
 
        }
        // 声明类，对象
        Cat c = new Cat();
        // 执行方法
        c.say();
    }
}
```
案例
```
package chapter01;
 
public class Java05_object {
    public static void main(String[] args) {
        // TODO 面向对象
        Teacher t = new Teacher();
        t.name = "rose";
        t.teach();
        Student s = new Student();
        s.name = "xiaoMing";
        s.study();
 
    }
}
class Teacher {
    String name;
    void teach() {
        System.out.println(name +"老师在上课");
    }
}
 
class Student {
    String name;
    void study(){
        System.out.println(name + "学生在听课");
    }
}
```
对象属性

定义：类的对象相同属性

语法：属性类型名称 = 属性值，即声明并初始化变量；如 String color = "pink"；

属性在构造对象是会默认初始化，初始化的值取决于属性值

变量的作用域仅仅在当前的大括号内有效

属性不仅在当前类可以用，在对象中也可以使用

对象方法

声明语法：【方法结果返回数据类型，没有结果写viod】方法名 () { 逻辑块 }

调用方法：对象.方法名()
```
package chapter01;
 
public class Java06_objectAttribute {
    public static void main(String[] args) {
        // TODO 对象实例化
        Animate a = new Animate();
        a.name = "dog";
        // 对象方法调用
        a.say();
    }
}
class Animate {
    String name;
    // 对象属性
    String color = "pink";
    //声明方法,boolean 是返回结果的数据类型，没有结果是void
    boolean say(){
        System.out.println(name+"可以说话，颜色是"+color);
        // 方法返回结果
        return false;
    }
}
```
对象方法参数

语法：方法名（参数类型1 名称1, 类型2 名称2）

传递多个参数时，需要注意的是
- 参数个数需要匹配
- 参数类型需要匹配
- 参数顺序需要匹配
可变参数：类型确定，个数不确定

语法：参数类型... 参数名称

可变参数声明在最后
```
package chapter01;
 
public class Java07_objectParam {
    public static void main(String[] args) {
        // TODO 方法参数
        Cloths c = new Cloths();
        c.use(3,"pink","old");
    }
}
class Cloths{
    String use(int year,String color,String... type){
        System.out.println("使用了"+year+"年，颜色是"+color+"，类型是"+type);
        return "使用了"+year+"年，颜色是"+color;
    }
}
```
方法参数传值方式
- 基本数据类型：数值，创建一个新的
- 引用数据类型：引用地址，共用祖先的
- 栈：变量，方法
- 堆：对象，成员变量
- 元空间（类的信息）：静态属性
3.2 静态 static
- 定义：与类相关，与对象无关的称之为静态，如对象鸟类中飞的方法,每个鸟都会飞
- 与类相关的属性，称静态属性
- 与类相关的方法，称静态方法
- 静态的可以直接通过类名访问，不用实例化对象
- 静态方法和静态属性添加 static 关键字
- 先有类，再有对象
- 成员方法可以访问静态属性和静态方法
- 类加载完后会自动调用静态代码块，完成静态属性的初始化功能
3.3 package 包

基本语法： package 包名

主要用于管理类

一个类可以没有包，一个包只能在源文件中使用一次，不可多次使用

为了与类区分，类是首字母大写，包全是小写

Java 中存在不同的包相同的类名，可以用包进行区分

在使用类的情况下，使用类的全名（包名+类型）

3.4 import 导入

主要用于导入类，import 只能在package 后，class 前使用

可多次使用，导入多个类

如需导入package中的多个类，可使用通配符*来简化操作

如果import 导入了不同包相同名称的类，在类前需要加包名进行区分

3.5 构造函数

用于构造对象

如果类中没有构造方法，java会自动添加一个公共的无参构造函数

基本语法：类名（）{ }
- 构造方法也有方法，方法没有void关键字
- 方法名和类名完全相同
- 如类中无构造方法，jvm会自动加构造方法，反之也不会
- 可传递参数，一般用于属性的赋值
```
package chapter01;
 
public class Java08_object_constructor {
    // TODO 面向对象-构造函数
    public static void main(String[] args) {
        Test t = new Test();
//        t.getFood("tomato");
        t.UserName ="tomato";
    }
}
class Test{
    String UserName;
    //  构造方法
    Test (String name){
        name = UserName;
        System.out.println("food:"+name);
    }
}
```
3.5 继承 extends
- 一个父类有多个子类，一个子类只有一个父类
- 子类可以继承父类的成员属性和成员方法
- 语法：子类 extends 父类
- 如父类和子类有相同的属性，用super和this区分
- super 表示父类属性，this 表示子类属性
- 构造方法执行顺序：父类 —— 子类，父类对象是在子类前创建的
- 默认情况，子类会调用父类的构造方法，完成父类的创建，使用super关键字
- 如果父类提供构造方法，子类显示调用super方法构建父类对象
```
package chapter01;
 
public class Java09_extends {
    public static void main(String[] args) {
        Son s = new Son();
        s.test();
    }
}
class Dad {
    String name = "大明";
    int age;
    void run(){
        System.out.println("I can run");
    }
}
class Son extends Dad {
    String name = "小明";
    void test(){
        System.out.println("super.name"+super.name); //大明
        System.out.println("this.name"+this.name); // 小明
    }
 
}
```
```
package chapter01;
 
public class Java09_extendsConstructor {
    public static void main(String[] args) {
        Son2 s1 = new Son2();
        Son2 s2 = new Son2();
        Son2 s3 = new Son2();
 
    }
}
class Dad2 {
    String name ;
    // 构造方法
    Dad2 (String dadname) {
        name = dadname;
        System.out.println("dad have run");
    }
}
class Son2 extends Dad2 {
    Son2() {
        super("candy");
    }
}
```
3.6 多态
- 定义：一个对象在不同场景下表现出来的不同状态和形态
- 多态语法就是对对象的使用场景进行了约束
- 一个对象可以使用的功能取决于引用变量的类型
```
package chapter01;
 
public class Java10_polymorphism {
    public static void main(String[] args) {
        // TODO 多态
        Person P1 = new Person();
        P1.test();
        Person P2 = new Girl();
        Person P3 = new Boy();
        P1.test();
        P2.test();
        P3.test();
        // P1.testGirl 不能这样写，多态的创建取决于变量类型 Person
 
        Girl r = new Girl();
        r.testGirl();
    }
}
class Person {
    void test() {
        System.out.println("test..");
    }
 
}
class Girl extends Person {
    void testGirl() {
        System.out.println("testGirl..");
    }
}
class Boy extends Person {
    void testBoy() {
        System.out.println("testBoy..");
    }
}
```
3.7 方法重载
- 同一个类，不能重复声明相同的方法和属性
- 重载：同类中方法名相同，参数列表（类型，个数，顺序）不一样，作用是使用场景不同
- 构造方法也存在重载
- 想要调用其他的构造方法需要用到this关键字
- 基本数据类型在匹配方法时，可以在数值不变的情况下，扩大数据的精度
- char 不能与byte做转换，byte 存在负数
```
package chapter01;
 
import java.awt.font.TextHitInfo;
 
public class Java11_chongzai {
    // TODO 重载
    public static void main(String[] args) {
        User u = new User(0001);
        u.login(18);
        u.login("lisa");
        u.login("lisa","175");
    }
}
class User {
    void login(String name){
        System.out.println("name");
    }
    void login(int age) {
        System.out.println("age");
    }
    void login(String name,String height){
        System.out.println("height");
    }
    User(){
        // 与 User() u = new User(99);相同，即this调用自己的构造函数
        this(99);
    }
    User(int id){
        System.out.println("id");
    }
}
```
3.8 方法重写
- 重写：在父类和子类中，子类重写父类，不会覆盖父类原有的方法
- 方法名，返回值，参数列表（个数、类型、顺序）相同
- 属性在哪里声明在哪里使用
- 对象左边（对象的引用数据类型）决定方法属性的使用场景
- 对象右边（对象）决定方法属性的使用
```
package chapter01;
 
public class Java12_rewrite {
    AAA a = new AAA(); //a.count = 11
    BBB b = new BBB(); // b.count = 21
    AAA c = new BBB();//c.cont = 21
 
}
class Parent{
    void info(String name ,String sex){
        System.out.println("Parent");
    }
}
class Child extends Parent{
    @Override
    void info(String name, String sex) {
        System.out.println("Child");
    }
}
class AAA {
    int a = 10;
    int count(){
        return a++;
    }
}
class BBB extends AAA {
    int a = 20;
    int count(){
        return a++;
    }
}
```
3.9 递归

定义：方法调用自身

阶乘：！5 = 5*4*3*2*1

递归方法有跳出的逻辑
```
package chapter01;
 
public class Java13_recursive {
    public static void main(String[] args) {
        // TODO 递归
        int result = compute(3);
        System.out.println(result);
    }
    public static int compute(int num){
        if (num <= 1){
            return 1;
        }else {
            return num * compute(num - 1);
        }
    }
}
 
```
3.10 访问权限

public：公共的，公共类只能有一个，且和源文件名相同，main方法是JVM调用，不考虑权限问题

private：同类，私有的，同类中可以使用，

default：同类，同包（路径），当不设定权限时，同一个包内可以使用，包权限（相同包路径）

protected：同类，同包，子类，子类可以访问

3.11 内部类

外部类：就是在源码中直接声明的类，不能用private和protected 修饰

内部类：在类中声明的类

内部类当做外部类的属性使用，需要创建外部类的属性使用
```
package chapter01;
// TODO 内部类和外部类
// 外部类
public class Java15_outerClass_and_innerClass {
    public static void main(String[] args) {
        A a = new A();
        A.B b = a.new B();
 
    }
}
class A {
    // 内部类
    class B {
    
    }
}
 
```
3.12 单例模式
- 默认的构造方法：公共的，无参的
- 类的创建复杂，类的对象消耗资源
- 单例模式：当内存中使用一个相同的对象时，应该只创建一个对象
```
package chapter01;
 
public class Java16_singleMode {
    public static void main(String[] args) {
        // TODO 单例模式
//        User22 U = new User22();
        User22 instance = User22.getInstance();
    }
}
class User22{
    // 构造方法
    private static User22 user22= null;
    private User22() {
 
    }
    // 方法 静态方法不能访问成员方法
    public static User22 getInstance() {
        if (user22 == null) {
            user22 = new User22();
        }
        return user22;
    }
}
```
3.13 final 关键字
- final 关键字：数据初始化后不被修改，final修饰变量，称为常量
- final 修饰的方法，不能被子类重写
- final 修饰类，该类没有子类
- final 不可修饰构造方法
- final 修饰方法参数列表，参数列表会无法修改
```
package chapter01;
 
public class Java17_final {
    public static void main(String[] args) {
        // TODO final关键字
        Student01 s = new Student01("lisi");
        System.out.println(s.name);
    }
}
class Student01 {
    final String name;
    public Student01(String name) {
        this.name = name;
    }
}
```
3.14 抽象 abstract
- 抽象类、抽象方法；先有对象（具体）在有类（抽象）
- 编写代码：类（抽象） => 对象（具体）
- 抽象方法：只有声明，没有实现的方法，abstract 返回值类型方法名（参数）
- 抽象类，不完整的类，abstract class 类名
- 一个类含抽象方法，这个类一定是抽象类
- 一个类是抽象类，这个类不一定有抽象方法
- 抽象类无法构建对象，但可通过子类构建对象
- 如果抽象类中含有抽象方法，子类需要重写抽象方法
- final 和 abstract 不能同时使用
```
package chapter01;
 
public class Java18_abstract {
    public static void main(String[] args) {
        // 抽象类、抽象方法 abstract
        catSon c = new catSon();
        c.eat();
    }
}
// 抽象类
abstract class Cat {
    //抽象方法
    public abstract void eat();
    void say(){
 
    }
}
class catSon extends Cat {
    // 重写抽象方法
    public void eat() {
        System.out.println("eat fish");
    };
}
```
3.15 接口 interface
- 接口：简单理解为规则
- 基本语法：interface 接口名称 { 规则属性，规则行为 }
- 接口是抽象的，规则的属性必须是固定值，且不能修改
- 属性和行为必须是公共的
- 属性是静态的，行为是抽象的
- 接口和类是两个层面的东西，接口可继承其他接口
- 类的对象要遵循接口，遵循称为实现，且可实现多个接口
```
package chapter01;
 
public class Java19_interface {
    public static void main(String[] args) {
        // TODO 接口 interface
        computer c = new computer();
    }
}
interface USB {
 
}
interface supply extends USB {
    public void powerSupply();
}
interface receive extends USB {
    public void powerReceive();
}
// 实现类
class computer implements supply {
    public supply usb1;
    public receive usb2;
    // 重写父类接口的方法
    public void powerSupply(){
        System.out.println("电脑提供能源");
        usb1.powerSupply();
        usb2.powerReceive();
    }
}
```
3.16 枚举 enum
- 枚举是一个特殊的类，包含一组特定的对象，这些对象不会发生改变，一般使大写的标识符
- 枚举会将对象放置在最前面，那么后面的语法用分号隔开
- 枚举类不能创建对象，它的对象是在内部自行创建的
- 如果需创建构造函数，着需在序列列表中加分号
```
package chapter01;
 
public class Java20_enum {
    public static void main(String[] args) {
        // TODO enum 枚举
 
    }
}
enum City {
    GUANGDONG("广东",01),BEIJING("北京",02),SHANGHAI("上海",03);
    City(String name,int code) {
        this.name = name;
        this.code = code;
    }
    public String name;
    public int code;
}
```
3.17 匿名类

定义：在特殊场合下，使用类的方法或功能采用匿名类
```
package chapter01;
 
public class Java21_anonymous {
    public static void main(String[] args) {
        // TODO 匿名类
        Me m = new Me();
        // 只使用类中的方法的类
        // 匿名类
        m.sayHi(new Person21() {
            // 等同于下面的 lisa 类
            @Override
            public String name(){
                return "lisa";
            }
        });
//        m.sayHi(new lisa());
//        m.sayHi(new rose());
 
    }
}
abstract class Person21 {
    public abstract String name();
}
class lisa extends Person21 {
    public String name(){
        return "lisa";
    }
}
class rose extends Person21 {
    public String name(){
        return "rose";
    }
}
class Me {
    public void sayHi(Person21 person21) {
        System.out.println("Hi"+person21.name());
    }
}
```
3.18 bean 规范
- 类作用：编写逻辑；建立数据库
- bean有无参公共的构造方法
- 属性私有化，有公共的get（）和set（）方法
```
package chapter01;
 
import java.security.PublicKey;
 
public class Java22_bean {
    public static void main(String[] args) {
        // TODO bean 规范
        User21 u = new User21();
        u.setId(0001);
        u.setPassword("admin");
    }
    public static boolean login(User21 u) {
        if (u.getId() == 0001){
            return true;
        } else {
            return false;
        }
    }
}
// bean 对象 数据模型
class User21 {
    private int id;
    private String password;
    
    public int getId() {
        return id;
    }
    
    public void setId(int id) {
        this.id = id;
    }
    
    public String getPassword() {
        return password;
    }
    
    public void setPassword(String password) {
        this.password = password;
    }
}
```
3.19 作用域

如果属性和局部变量相同，会有限访问局部变量
```
package chapter01;
 
public class Java23_scope {
    public static void main(String[] args) {
        // TODO 作用域
        Fish f = new Fish();
        f.test();
    }
}
class Pig {
    public static String name = "pig";
}
class Fish extends Pig {
    public static String name = "fish";
 
    public static void test() {
        // name 作用域在 test 方法里，局部变量
        String name = "yu";
        System.out.println(name);
        System.out.println(Pig.name);
    }
}
```
3.20 总结 java 关键字

访问权限修饰符的关键字
- public：所有的包、方法、类、属性、成员都可以访问
- Private：只能在当前类中使用
- fridently：当前类，同包可以访问
- default：同包，同类是可以访问的
- protected：在当前类，同包，子类可以访问
定义类、函数、变量的关键字
- abstract：不可实例化，用于类和方法，子类可以重写方法，一定有构造器
- final：修饰变量值不可以变（常量），子类不可重写，类不可被继承
- abstract 和final 关系：类中不能同时存在这两个
- static：被所有对象共享，静态成员不可以访问非静态成员，反之则不行
- synchronized: 线程、同步，不继承
补充：
- 构造方法：修饰符类名（）{}，重载，名字同类名，无返回值，父子之间
- 重写（Override）：方法名、参数列表、返回值相同，访问权限比父类大
- 访问权限：Public > protected > default > private
- 重载（Overload）：参数列表（类型、个数、顺序）不同，在同类中
定义类和类之间的关键字
- implements: 实现类、接口，一个类可以实现多个接口
- extends: 继承、拓展类，子类可继承父类的属性方法，一个类可拓展一个类，重写（非final）
建立实例和引用实例的关系，判断实例关键字
- this：本类，引用当前实例
- new：创建，创建新的实例
- super：父类、超类，super(),用于调用父类的方法或者是实例中
- instanceof：确定对象所属的类，Dog d = new Dog(), d instanceof Dog ,返回布尔值true
异常处理的关键字
- try：捕获异常，引发异常语句，一个try 必须有一个 catch 或者是finally 语句
- catch：处理异常，
- finally：最后， cat... catch...finally,一定会执行的语句
- throw：抛出异常对象，在catch 里面使用，用于方法实现（里面）中，只能抛出一种异常
- throws：用于方法实现（头部）中，可抛出多个异常
```
public void str2int(String str) throws Exception { //这里将得到的异常向外抛出
    try {
        System.out.println(Integer.parseInt(str));
    } catch(NumberFormatException e) {
        //TODO 这里可以做一些处理，处理完成后将异常报出，让外层可以得到异常信息
        throw new Exception("格式化异常");
    }
}
```
用于包的关键字
- package：java包，源文件中第一行代码指定所在的java包
- import：导入，导入包、类等，每个源文件中需要导入包
其他修饰符关键字
- native：本地，修饰本地方法
- transient：对象序列化，使用场景如密码
- assert：true进行执行，false抛出AssertionError错误终止/java.lang.AssertionErrorbin并输入
- strictfp：精确浮点
相关阅读:
【毕业设计】1-1Matlab小电流接地系统的建模与单相故障的仿真分析（仿真工程文件+结果图+论文+PPT）
23.1 Bootstrap 表格
 编译原理总结
 聚乳酸-羟基乙酸共聚物修饰卵清白蛋白OVA/小鼠血清白蛋白（MSA）/大鼠血清白蛋白（RSA）齐岳
 [SpringBoot]配置文件①(配置文件格式、yaml配置及读取)
不规则间隔时间序列转规则时间序列
 029-从零搭建微服务-消息队列（一）
MySQL进阶篇（五）- 锁
 【macOS付费软件推荐】第3期：Sibelius Ultimate
按键精灵中的UI界面操作
原文地址：https://blog.csdn.net/weixin_49555741/article/details/127956557

1.基础概念

2.IDEA 开发工具

2.1 JDK环境配置

2.2 注释和变量

2.3 标识符

2.4 数据类型

2.5 算术运算符

2.6 赋值运算符

2.7 关系运算符

2.8 逻辑运算符

2.9 三元运算符

2.10 流程控制

3. 面向对象

3.1类和对象

3.2 静态 static

3.3 package 包

3.4 import 导入

3.5 构造函数

3.5 继承 extends

3.6 多态

3.7 方法重载

3.8 方法重写

3.9 递归

3.10 访问权限

3.11 内部类

3.12 单例模式

3.13 final 关键字

3.14 抽象 abstract

3.15 接口 interface

3.16 枚举 enum

3.17 匿名类

3.18 bean 规范

3.19 作用域

3.20 总结 java 关键字