本文主要是介绍java基础复习(一)，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

java revise（java基础复习）

• 数据类型
• • 八种基本数据类型
  • • 注意
  • 包装类
  • • 基本概念
    • 存在价值
    • 那些语法要求只能使用对象类型
    • 装箱和拆箱
• 运算符
• • 算术运算符
  • 比较运算符
  • 自增自减
  • 逻辑运算
  • 三元运算符
  • 比较运算符
  • 运算符的优先级和结合性
• 程序语句类型
• • 顺序
  • 分支
  • • 单选分支
    • 多选分支
  • 循环
• 面向对象
• • 概念
  • 继承和多态
  • 面向对象编程过程
• 单例设计模式
• • 显性思想
• 父类子类代码执行顺序
• • 父类代码
  • 子类代码
  • 执行结果：
  • 结论：

数据类型

八种基本数据类型

1.byte
2.short
3.int
4.long
5.float
6.double
7.char
8.boolean

注意

byte ，short，char三种类型或其混合类型，默认的转化类型为int
下面展示一些 内联代码片。

        byte a=0;
        byte b=1;
        //byte c=a+b;//执行报错
        int c=a+b;

当执行强制类型转化注意精度丢失

包装类

基本概念

Java有8种基本数据类型：整型(byte、short、int、long)、浮点型(float、double)、布尔型boolean、字符型char，相对应地，Java提供了8种包装类Byte、Short、Integer、Long、Float、Double、Boolean、Character。包装类创建对象的方式就跟其他类一样。

存在价值

将基本类型纳入oop的体系

那些语法要求只能使用对象类型

泛型， 集合（集合可以放基本类型，有装箱的功能），null值只能赋值给对象类型，synchronized 加锁对象只能是对象类型

装箱和拆箱

集合只能存储对象类型，但因为有自动装箱的特性，所有基本类型也可以直接存入集合，但是，基本类型向自动装箱为包装类类型，然后再存入集合

运算符

算术运算符

+，-,*,/

比较运算符

返回值是布尔类型

自增自减

i++，++i，i–，--i
i++，先用i计算，之后i+1；
++i，i先加1，再计算。

逻辑运算

|| 或 ， &&与
注意：
运算数和结果都是boolean
注意程序执行时逻辑短路

三元运算符

第一个是条件表达式，剩余两个为值，条件表达式为真时运算取第一个值，为假时取第二个值。
如：a = 20 < 45 ? true : false
执行结果：a=true

比较运算符

<,=,>,<=,>=

运算符的优先级和结合性

（在idea编辑器中，可选中公式按）

程序语句类型

顺序

分支

单选分支

if if-else if - else if 具有排他性 至多执行一个分支

多选分支

switch -case 多条分支同时执行 结合break 可以实现单选

循环

for while
注意：
1.越界异常问题，注意控制循环因子和边界值
2.死循环
3.循环与break和continue的搭配

面向对象

概念

简单里说，就是做事情找谁去做，这个谁就是对象
与面向过程对应，（这个事情怎么做）
核心关键字：抽象，封装，继承，多态
补充关键字：static，final，abstract，interface
static 静态
final 最终 final 修饰的类、属性、方法不可被更改
abstract 抽象 abstract 修饰的类，必须被继承；abstract 修饰的方法，应被重写
interface 接口

继承和多态

继承： 子类 ：子类继承父类，获取可继承的属性方法
            ~~~~~~~~~~~            父类 : 父类派生子类
多态： 子类： 子类重写父类的方法【重写】
            ~~~~~~~~~~~            父类 :父类指代子类【塑性】
单继承和多继承：
            ~~~~~~~~~~~             extends：单继承，类与类之间是单继承
            ~~~~~~~~~~~             implements ：多继承 类与接口之间
            ~~~~~~~~~~~             extends： 多继承 接口和接口之间

面向对象编程过程

1.创建一个类
2.抽取共同的属性行为
3.封装：属性->成员变量，行为->成员方法
4.创建类的实例对象
5，进行方法调用

单例设计模式

一个类在任何调用下获取的实例对象只有唯一的一个

显性思想

1.建立单例模式类的静态实例变量
2.将构造方法私有化
3.提供一个静态的方法接口。

//单例设计模式
public class SingletonDemo {
   //成员变量
    //静态的单例实例变量
    private static SingletonDemo singletonDemo;
    //单例模式，构造方法私有化
    private SingletonDemo(){
    }
    //成员方法
    /*
    * 获取单例模式实例对象
    *
    * @return 唯一的实例对象
    * */
    public static SingletonDemo getSingletonDemoIntance(){
        //如果是第一次获取实例对象，需new创建
        if(singletonDemo==null){
             singletonDemo=new SingletonDemo();
        }
        return singletonDemo;
    }
}

import org.junit.Test;
public class TestDriver {
    @Test
    public void test(){
        //获取单例模式的实例对象
        SingletonDemo singletonDemo=SingletonDemo.getSingletonDemoIntance();
        SingletonDemo singletonDemo1=SingletonDemo.getSingletonDemoIntance();
        //判定内存中创建的对象是否是同一个
        System.out.println(singletonDemo==singletonDemo1);
    }
}

父类子类代码执行顺序

父类代码

 public class Person {
        private String name;
        private Date date;
        public Person(){
            System.out.println("调用了父类构造方法");
        }
        {
            System.out.println("父类非静态代码块");
        }
       //静态代码块----初始化用，执行且执行一次
        static {
           System.out.println("  父类静态代码块  ");
       }static {
            System.out.println("  父类静态代码块111  ");
        }

        public Person(String name, Date date) {
            this.name = name;
            this.date = date;
        }

        public String getName() {
            return name;
        }

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

        public Date getDate() {
            return date;
        }

        public void setDate(Date date) {
            this.date = date;
        }

        public void eat(){
            System.out.println("吃了");
        }

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

子类代码

public class Student extends Person{
    private Integer id;
    public Student(){
        System.out.println("调用了子类构造方法");
    }
    static {
        System.out.println("子类静态代码块");
    }
    {
        System.out.println("子类非静态代码块");
    }
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }
}

测试类

impor org.junit.Test;

public class TestDriver {
    @Test
    public void test(){
        Student student = new Student();
        System.out.println("-------------------------------");
        Student student01 = new Student();
    }
}

执行结果：

结论：

执行顺序：
1.先执行父类和子类所有的静态方法或方法块
2.执行父类的非静态的代码块
3.执行父类的构造方法
4.执行子类的非静态代码块
5.执行子类的构造方法
总结：
静态的内容首先执行，且只执行一次
其次执行非静态代码块
再次是构造方法
非静态的代码块和构造方法按照先执行父类再执行子类的递归方式执行
非静态代码块每次调用new时都会再执行，而静态代码只在第一次被new时执行

这篇关于java基础复习(一)的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！