JAVA 基础

时间:2021-07-30
本文章向大家介绍JAVA 基础,主要包括JAVA 基础使用实例、应用技巧、基本知识点总结和需要注意事项,具有一定的参考价值,需要的朋友可以参考一下。

基础

java定义变量

/**
 * java中的变量定义
 */
public class Demo01 {

    private String $1 = "";//$开头
    private String _1 = "";//_开头
    private String abc = ""; //字母开头

}

java数据类型

  • 基本数据类型

    /**
     * java数据类型(强类型语言)
     * 1、基本数据类型
     * 2、引用数据类型(除基本数据类型外,其他都是引用数据类型)
     */
    public class Demo02 {
        public static void main(String[] args) {
            //1、基本数据类型(整形)
            byte num1 = 127; //范围:-128~127
            short num2 = 32767; //范围:-32768~32767
            int num3 = 2147483647;//int 4个字节范围范围:-2147483648~2147483647
            //末尾添加L
            long num4 = 9222L;//long 8个字节范围:-9223372036854775808到9223372036854775807
    
            //2、基本数据类型(浮点型)
            //末尾添加F
            float num5 = 8.4F ;// 占4个字节
            double num6 = 22.22;//占8个字节
    
            //3、基本数据类型(字符类型)
            char num7 = 'a';//占2个字节
    
            //4、基本数据类型(布尔类型)
            boolean num8 = false;
        }
    }
    
  • 引用数据类型

引用数据类型(除基本数据类型外,其他都是引用数据类型)

知识拓展

  • 进制之间的定义
//二进制0b,八进制0,十进制,十六进制0x(范围0-9 a-f)
int num1 = 0b10;//二进制
int num2 = 010;//八进制
int num3 = 10;//十进制
int num4 = 0x10;//十六进制
System.out.println(num1);
System.out.println(num2);
System.out.println(num3);
System.out.println(num4);
  • 浮点型

浮点型之间不要进行比较容易产生误差,比较需要转换成 Bigdecimal 进行比较。float占4个字节,double占8个字节

//不要用用浮点型(double 、float) 进行比较,容易产生误差
//BigDecimal 来进行计算小数
float f = 0.1F;
double d = 1/10;

if(d==f){
    System.out.println("f和d的值相等");
}else{
    System.out.println("f和d的不值相等");
}

BigDecimal bf = new BigDecimal(f);
BigDecimal bd = new BigDecimal(d);

if(bf.compareTo(bd) == 0){
    System.out.println("bf和bd的值相等");
}else{
    System.out.println("bf和bd的值相等");
}
  • 字符型

字符型占2个字节

char c1 = 'a';
char c2 = '中';
System.out.println((int)c1);
System.out.println((int)c2);

//转义字符
//\n 和 \t
System.out.println("hello\tworld");//tab
System.out.println("hello\nworld");//换行

变量和常量

  • 变量

变量的作用域:类变量,实例变量,局部变量。

类变量:用static定义。

局部变量:必须声明,必须初始化。

实例化变量:从属于对象,如果不初始化,为该类型的默认值

  1. 基本类型:0;0.0
  2. 布尔类型:false
  3. 非基本类型:null
  • 常量

final定义

/**
 * 1、变量,常量
 * 2、变量的作用域
 *  类变量,实例变量,局部变量
 */
public class Demo04 {

    //实例变量:从属于对象,如果不初始化,为该类型的默认值
    //基本类型:0;0.0
    //布尔类型:false
    //非基本类型:null
    String str ;

    //类变量
    static String salary = "类变量" ;

    //常量:final 定义常量,用大写字母
    final String  STR2 = "常量";

    public static void main(String[] args) {
        //局部变量:必须声明,必须初始化
        int i = 10;
        System.out.println(i);

        //实例变量
        Demo04 demo04 = new Demo04();
        System.out.println(demo04.str);

        //常量
        System.out.println(demo04.STR2);

        //类变量
        System.out.println(salary);
    }
}

java运算符

  • 一元运算符
public class Demo01 {
    public static void main(String[] args) {
        //一元运算符: ++ ; --
        int a = 3 ;
        int b = a++ ;
        int c = ++a;
        System.out.println(a); //输出为:5
        System.out.println(b);//输出为:3
        System.out.println(c);//输出为:5

    }
}
  • 逻辑运算符
public class Demo02 {
    public static void main(String[] args) {
        //逻辑运算符包括:与、或、非
        boolean a = true;
        boolean b = false;
        System.out.println("a && b:"+(a && b)); //两个为真,才为真
        System.out.println("a || b:"+(a || b)); //至少一个为真,才为真
        System.out.println("!(a||b):"+!(a||b));//如果为真,则为假。如果为假,则为真。

        //短路运算 &&
        int c = 5 ;
        System.out.println(c>10 && c++>0);
        System.out.println(c);//输出为5
    }
}
  • 位运算
public class Demo03 {
    public static void main(String[] args) {
        /*
           A = 0000 1111
           B = 1111 0000

           A&B = 0000 0000
           A|B = 1111 1111
           A^B = 1111 1111 //相同则为0 ,不同则为1
           ~B = 0000 1111
        */

        //2*8
        System.out.println(2<<3);

        //16
        System.out.println(16>>3);
    }
}

java流程控制

  • switch 穿透
package scanner;

/**
 * switch
 */
public class Demo02 {
    public static void main(String[] args) {
        char grade = 'A'; //等级
        
        //用法
        switch (grade){
            case 'A':
                System.out.println("等级为A");
                break;
            case 'B':
                System.out.println("等级为B");
                break;
            case 'C':
                System.out.println("等级为C");
                break;
            default:
                System.out.println("等级为DEFAULT");
        }
    }
}

九九乘法表

public class Demo01 {
    public static void main(String[] args) {
        for (int i = 1; i <=9; i++) {
            for (int j=1 ; j<=i ;j++) {
                System.out.print(j+"*"+i+"="+ (i*j)+"    ");
            }
            System.out.println();
        }
    }
}

break和continue

  • break 强制退出循环
  • continue 终止某次循环
  • return 返回结果,终止方法
public class Demo02 {
    public static void main(String[] args) {
        int i = 0;
        while (i<100){
            if(i%10 == 0){
                System.out.println("**");
                //i++;//解决办法
                continue;//continue 不会执行后面的i++ 陷入死循环
            }
            System.out.print(i+" ");
            i++;
        }
    }
}

可变参数

public class Demo02 {

    public static void main(String[] args) {
        method01(111,2,23,3,2);
    }
    //方法
    public static void  method01(int ... i){
        System.out.println(i.length);//输出0
        for (int j = 0; j <i.length ; j++) {
            System.out.println(i[j]);
        }
    }
}

方法递归

public class Demo03 {

    public static void main(String[] args) {
        diGui(5);
    }
    //方法的递归
    public static int diGui(int i){
        if(i==1){
            return 1;
        }else{
            return i*diGui(i-1);
        }
    }
}

数组对象

  • 数组一旦初始化长度固定,类型确定
  • 所有new()出来的对象都存放在
  • 对于数组中没有赋值的元素都是默认值
  • 多维数组的创建
/**
 * 多维数组
 */
public class Demo01 {

    public static void main(String[] args) {
        int [][] arri = {{1,3,5,7,9},{2,4,6,8,0}};
    }
}
  • 数组常用工具类Arrays
/**
 * Arrays常用工具类
 */
public class Demo02 {
    public static void main(String[] args) {

        int [] i = {8,7,6,5,4,3,2,1};
        //转化成字符串
        System.out.println(Arrays.toString(i));//[8, 7, 6, 5, 4, 3, 2, 1]
        //字符串的排序
        Arrays.sort(i);
        System.out.println(Arrays.toString(i));//[1, 2, 3, 4, 5, 6, 7, 8]
        //给数组中的元素默认赋值
        Arrays.fill(i,1);
        System.out.println(Arrays.toString(i));//[1, 1, 1, 1, 1, 1, 1, 1]
    }
}
  • 冒泡算法
/**
 * 冒泡排序
 */
public class Demo03 {

    public static void main(String[] args) {
        int [] arri = {1,3,5,7,9,2,4,6,8,0};
        sort(arri);
        System.out.println(Arrays.toString(arri));
    }
    /**
     * 排序
     * @param arri
     * @return
     */
    public static int [] sort(int [] arri ){
        int temp = 0;
        int ilength = arri.length -1 ; //数组长度,-1:防止下一个数组越界
        for (int i = 0; i <arri.length; i++) {
            //目的最后一个为最小的
            for(int j=0 ;j<ilength-i;j++){
                int jnext = j+1;
                if(arri[j]<arri[jnext]){
                    temp = arri[j];
                    arri[j]= arri[jnext];
                    arri[jnext] = temp;
                }
            }
        }
        return arri;
    }
}

面向对象

  • 面向对象编程的本质

    • 以类的方式组织代码,以对象的组织(封装)数据。
  • 抽象:面向对象是抽象的,面向过程是具体的。

  • 值传递和引用传递

public class Demo01 {
    public static void main(String[] args) {
        //值传递
        int i = 0;
        System.out.println(i);//输出:0
        changValue(i);
        System.out.println(i);//输出:0

        //引用传递
        Person person = new Person();
        System.out.println(person.name);//输出:null
        changValue(person);
        System.out.println(person.name);//输出:zhangsan
    }
    public static void changValue(int i ){
        i = 5;
    }
    public static void changValue(Person person){
        person.name = "zhangsan";
    }
}

class Person{
    String name ;
}
  • 构造器
  • 创建对象内存分析
    • 创建对象引用都在中,中存放的都是对象实例。
  • 复习

面向对象的三大特征

  • 封装
    • 提高程序的安全性
    • 隐藏代码的实现细节
    • 统一接口
    • 提高系统可维护性
  • 继承
    • java中只有单继承,没有多继承。一儿子只能有一个爸爸,一个爸爸可以有多个儿子。
    • super的理解
      • super调用父类的构造方法,必须在构造方法的第一个。
      • super必须只能出现在子类的方法和构造方法中。
      • super和this不能同时出现在构造方法中。
    • super VS this
      • 代表的对象不同
        1. super代表父类对象的应用
        2. this本身调用者对象。
      • 前提
        1. this没有继承也可以使用。
        2. super只有继承才可以使用。
      • 构造方法
        1. this() 本身的构造方法。
        2. super() 父类的构造方法。
    • 重写
      • 继承关系,子类重写父类方法
      • 重写特点
        1. 方法名必须相同,
        2. 参数列表相同,
        3. 修饰符:范围可扩大,不能缩小
  • 多态
    • 多态是方法的多态,属性没有多态。
    • 父类和子类关系
    • 存在条件:继承关系,方法需要重写,父类应用指向子类

static关键字

public class Demo01 {

    static{
        System.out.println("静态代码块");
    }

    {
        System.out.println("匿名代码块");
    }

    public Demo01(){

        System.out.println("构造方法");
    }
    
    public static void main(String[] args) {

        Demo01 demo01 = new Demo01();
        System.out.println("========");
        Demo01 demo02 = new Demo01();
        System.out.println("========");
        Demo01 demo03 = new Demo01();
        
       /*输出结果:
       
       	静态代码块
        匿名代码块
        构造方法
        ========
        匿名代码块
        构造方法
        ========
        匿名代码块
        构造方法
        
        */
        
    }
}

抽象类

  • abstract用在类上是一个抽象类
  • abstract用在方法上就是一个抽象方法
  • 抽象类的抽象方法都要由子类实现
  • 抽象类不能实例化,只能靠子类实现
  • 抽象类中可以写普通方法,抽象方法只能写在抽象类中

接口

  • 定义关键字 interface
  • 接口中的所有定义都是抽象的 public abstract
  • 接口可以多继承

内部类

  • 内部类可以操作类的私有属性

  • 内部类可以获得外部类的方法

  • 局部内部类

  • 匿名内部类

异常

原文地址:https://www.cnblogs.com/chenhu1991/p/15078633.html