Java基础知识

目录

一 Java基础

1.计算机存储单元

2.Java基础知识

3.常量的分类

4.数据类型

5.变量的注意事项

6.数据类型转换

7.运算符

8.方法

9、流程控制

10.Idea常用快捷键

11.方法重载

12.数组

13.Java内存划分 

二 Java面向对象

1.类的定义

2.对象的创建和使用

3.局部变量和成员变量

 4.面向对象三大特征之封装性

5.面向对象三大特征(继承性)

6.抽象类

7.接口


一 Java基础

1.计算机存储单元

位(bit):一个数字0或一个数字1,代表1位。

字节(byte):每逢8位代表1个字节,是数据存储的最小单位。

2.Java基础知识

jre是Java程序的运行环境,包含JVM和运行时所需要的核心库。

jdk是Java开发的工具包,包含jre和开发人员使用的工具。

javac.exe是编译器。

java.exe是解释器

3.常量的分类

字符串常量:凡是用双引号引起来的常量。

字符常量:凡是用单引号引起来的常量。

布尔常量:true、false

空常量:null(不能直接打印输出)

整数常量和浮点数常量

4.数据类型

  • 引用数据类型:字符串、类、数组、接口。
  • 基本数据类型:
    • 整数型:
      • byte:占1byte,范围是 -128~127
      • short:占2byte,范围是 -32768~32767
      • int(默认):占4byte,范围是 -2^31~2^31-1
      • long:占8byte,范围是 -2^61~2^61-1
    • 浮点型:
      • float:占4byte,范围是 1.4013E-45~3.4028E+38
      • double(默认):占8byte,范围是  4.9E-324~1.7977E+308
    • 字符型:
      • char:占2byte,范围是0~65535
    • 布尔型:
      • boolean:占1byte,范围是true和false
  • 注意事项:
    • 字符串类型不是基本数据类型,而是引用数据类型。
    • 浮点型可能只是一个近似值,并非精确值。
    • 数据范围与字节数不一定相关。
    • 浮点数当中的默认类型是double,如果一定要使用float,需要加一个后缀F。
    • 如果是整数,默认类型是int,如果一定要使用long,需要加一个后缀L。

5.变量的注意事项

  • 如果创建多个变量,那么变量之间的名称不能重复。
  • 对于float和long类型来说,字母后缀L和F不要丢掉。
  • 如果使用byte或者short类型的变量,那么右侧的变量值不能超过左侧类型的变量。
  • 没有进行赋值的变量,不能直接进行使用,一定要赋值之后,才能够进行使用。
  • 变量的使用域不能超过作用域的范围。

6.数据类型转换

  • 自动类型转换。
    • 特点:代码不需要进行特殊处理,自动完成。
    • 规则:数据范围由小到大,与字节数不一定相关。
  • 强制类型转换。
    • 特点:代码需要特殊的格式处理,不能自动完成。
    • 规则:范围小的类型=(范围小的类型)原本范围大的类型。
int num = (int)100L;
  • 注意事项。
    • 强制类型转换一般不建议使用,因为可能发生精度损失,数据溢出的现象。
    • short/byte/char这三种类型都可以发生数学运算,都会被提升到int类型,再进行计算。
    • boolean类型不能发生数据类型转换。

7.运算符

  • 算术运算符。
    • +:加法,字符串拼接
    • -:减法
    • *:乘法
    • /:除法
    • %:取模运算,两个数字相除取余数
    • ++,--:自加自减
  • 赋值运算符。
    • =:基本赋值运算符
    • +=,-+:复合赋值运算符,其中隐含了一个强制类型转换
  • 比较运算符。
    • &&:与
    • ||:或
    • !:非
  • 三元运算符。
    • 数据类型 变量名 = 条件判断?表达式A:表达式B

8.方法

定义一个方法的格式:

public static void 方法名称(){
    方法体
}
  • 方法命名规则:小驼峰。
  • 方法的定义不能包含嵌套关系。
  • 方法调用:方法名称();
  • 方法定义好了是不会进行执行的,如果想要执行,一定要进行调用。

9、流程控制

  • 顺序结构
  • 判断结构
    • if语句
      if(判断条件){
          语句体1
      } else {
          语句体2
      }
    • if...else语句
      if(判断条件){
          语句体1
      } else if{
          语句体2
      } else {
          语句体3
      }

       

  • 循环结构
    • for语句
      for(初始化表达式;布尔表达式;步进表达式){
          循环体
      }

       

    • while循环
      while(布尔表达式){
          循环体
          步进表达式
      }
    • do...while循环
      do{
          循环体
          步进表达式
      } while(条件判断)
  • 选择结构
    • switch语句
      switch(表达式){
          case 常量值1:
              语句体1
              break;
          case 常量值2:
              语句体2
              break;
          case 常量值3:
              语句体2
              break;
          default:
              语句体4
              break;
      }
    • 注意事项
      • 多个 case后面的值不可以重复。
      • 表达式种支持的数据类型
        • 基本数据类型:byte/short/char/int
        • 引用数据类型:String字符串,enum枚举
  • 条件控制
    • break:一旦执行,整个循环立即结束
    • continue:一旦执行,立刻跳过当前次循环内容,马上开始下一次循环

10.Idea常用快捷键

  • Alt+Enter:导入包,修正代码。
  • Ctrl+Y :删除光标所在的行。
  • Ctrl+D:复制光标所在的行,插入光标位置下面。
  • Ctrl+Alt+L:格式化代码。
  • Ctrl+/:单行注释,再次按取消。
  • Ctrl+Shift+/:选中代码注释。
  • Alt+Ins:自动生成代码。
  • Alt+Shift+上下箭头:移动当前代码行。
  • fori:立即创建for循环。

11.方法重载

  • 方法重载与下列因素有关。
    • 参数个数不同。
    • 参数类型不同。
    • 参数的多类型顺序不同。
  • 方法重载与下列因素无关。
    • 与方法参数的名称无关。
    • 与方法返回值类型无关。

12.数组

  • 数组是一个容器,可以同时存放多个数据。

  • 特点

    • 数组是一种引用数据类型(以基本数据类型为基础)。

    • 数据当中的数据类型必须统一。

    • 数组的长度在程序运行期间是不可改变的。

  • 数字的初始化
    • 动态初始化
      // 数组类型[] 数组名称 = new 数组类型[数组长度]
      int[] arrayA = new int[10];

       

    • 静态初始化
      // 标准格式:数组类型[] 数组名称 = new 数组类型[] {元素1,元素2}
      int[] arrayA = new int[] {5,13,1};
      // 省略模式:数组类型[] 数组名称 = {元素1,元素2}
      int[] arrayA = {5,13,1};

       

    • 注意事项
      • 静态初始化标准格式可拆分为两个步骤,但是省略模式不能拆分。
      • 静态初始化标准格式可以拆分为两个步骤,但是省略模式格式不能拆分。
      • 动态初始化也可以拆分为两个部分。
      • 数组必须经过new初始化后才能使用其中的元素,如果只是赋值了一个null,那么将会发生空指针异常
  • 数组使用方法
    • 获取数组长度
      // 格式:数组名称.length
      int[] arrayA = new int[] {4,13,13};
      int len = arrayA.length

       

    • 遍历数组
      int[] arrayA = new int[] {5,3,1,3};
      for(int i  = 0; i < array.length; i++){
          
      }

       

    • 数组元素反转
      int[] arrayA = new int[] {4,13,45};
      for(int min = 0, max = arrayA.length-1; min < max; min++,max--){
          int temp = arrayA[min];
          arrayA[min] = arrayA[max];
          arrayA[max] = temp;
      } 

       

13.Java内存划分 

  • 栈:存放的都是方法中的局部变量,方法的运行一定要在栈中进行。
  • 堆:凡是new出来的东西,都在堆当中。
  • 方法区:存储class相关信息,包含方法的信息等。
  • 本地方法栈:与操作系统相关。
  • 寄存器:与CPU相关。

二 Java面向对象

面向过程:当需要事先一个功能的时候,每一个具体的不足都要自己亲历而为,详细处理每一个细节。

面向对象:当需要实现一个功能的时候,不关心具体的实现步骤,而是找一个已经具有该功能的人,来帮我做事。

1.类的定义

成员变量(属性)

成员方法(行为)

注意事项:成员方法是直接定义在类中,在方法外面;成员方法不写static关键字

2.对象的创建和使用

(1)导包:也就是需要使用的类,在什么位置

(2)创建对象

// 类名称 对象名 = new 类名称()
Student stu = new Student()

(3)使用

使用成员变量:对象名.成员变量名

使用成员函数:对象名.成员函数名(参数)

3.局部变量和成员变量

  • 定义的位置不一样
    • 局部变量:在方法内部。
    • 成员变量:在方法内部,直接写在类中。
  • 作用范围不一样
    • 局部变量:只有在方法类中才能使用,出了方法就不能使用。
    • 成员变量:整个类中都能使用。
  •  默认值不一样
    • 局部变量:没有默认值,如果想要使用,必须手动进行复制。
    • 成员变量:如果没有默认值,会有默认值。
  • 内存位置不一样
    • 局部变量:栈。
    • 成员变量:堆。
  • 生命周期不一样
    • 局部变量:随着方法进栈而诞生,随着方法出栈而消失。
    • 成员变量:随着对象创建而诞生,随着对象垃圾回收而消失。

 4.面向对象三大特征之封装性

封装在Java中体现:方法就是一种封装,private也是一种封装。

  • private
    • 使用private进行修饰,只能在本类中进行使用,不能直接访问。
    • 利用set,get方法对参数进行修改。
    • 自动生成get,set方法(Code->Generate->Getters and Setters)
      public void setNum(int num){
          age = num;
      }
      public int getNum(){
          return age;
      }

       

  • this
    • 当方法成员变量和局部变量重名的时候,根据“就近原则”,优先使用局部变量。
    • 如果需要访问本类的成员变量,使用this关键字。
    • 通过谁调用,this指的就是谁
  • 构造方法
    • 格式
      public 类名(参数类型 参数名称){
          方法体
      }

       

    • 自动生成构造方法。(Code->Generate->Constructor->Select None)
    • 注意事项
      • 构造方法的名称必须和所在的类的名称完全一样,就连大小写也一样。
      • 构造方法不要写返回值的类型,连void也不用写。
      • 构造方法不能return一个具体的返回值。
      • 如果没有编写任何的构造方法,那么编译器将默认赠送一个构造方法,没有参数。
      • 一旦编写了一个构造方法,那么编译器不会赠送。

5.面向对象三大特征(继承性)

继承是多态的前提,没有继承就没有多态

  • 继承的格式
    public class 父类名称{
    
    }
    public class 子类名称 extends 父类名称{
    
    }

     

  • 继承中成员变量的访问规则
    • 在父子类继承关系中,如果成员变量重名,则创建子类对象是,访问又两种方式:
      • 直接通过子类对象访问成员变量。
      • 间接通过成员方法访问成员变量。
  • 区分三种变量重名的问题
    • 局部变量:num。
    • 本类的成员变量:this.num。
    • 父类的成员变量:super.num。
  • 继承中成员函数的访问规则
    • 创建的对象是谁,就优先用谁,没有就往上找。
  • 方法的重写(override)和重载(overload)
    • 重写:在继承关系中,方法名一样,参数列表一样。
    • 重载:在继承关系中,方法名一样,参数列表不一样。
    • 重写的注意事项:
      • 必须保证父子类之间的名称相同,参数列表也相同。
      • 子类方法的返回值鼻血小于等于父类方法返回值的范围。
      • 子类方法的权限必须大于等于父类方法的权限修饰符(public>protected(default)>private)。
  • 继承中构造方法的访问特点
    • 子类构造方法当中有一个默认的"super()"调用,所以一定是先调用父类的构造方法,后执行子类的构造方法。
    • 子类构造方法可以通过super关键字来调用父类的构造方法。
    • 父类的super()调用必须是子类构造方法的第一个语句,不能一个子类构造调用多个super构造。
  • super关键字的用法
    • 在子类的成员方法中,访问父类的成员变量。
    • 在子类的成员方法中,访问父类的成员方法。
    • 在子类的构造方法中,访问父类的构造方法。
  • this关键字的用法
    • 在本类的成员方法中,访问本类的成员变量。
    • 在本类的成员方法中,访问本类的另一个成员方法。
    • 在本类的构造方法中,访问本类的另一个构造方法。
      • this调用必须是构造方法中的第一个语句,也是唯一一个,不能与super同时使用。
  • 继承的三个特点
    • 单继承,一个类的直接父类只能有唯一的一个。
    • 多级继承。
    • 一个父类可以有多个子类。

6.抽象类

  • 抽象方法和抽象类的格式
    // 抽象方法:加上abstract,然后去掉大括号,直接分号结束
    public abstract eat();
    // 抽象类:抽象方法所在的类,在class之前加上abstract
    abstract class Dog{
    
    }

     

  • 抽象方法和抽象类的使用
    • 不能直接创建抽象类对象。
    • 必须用一个子类继承抽象类。
    • 子类必须重写抽象父类中的所有方法。
    • 创建子类对象进行使用。
  • 注意事项
    • 抽象类不能创建对象
    • 抽象类中,可以有构造方法,是供子类创建对象是,初始化父类成员用的。
    • 抽象类中,不一定包含抽象方法,但是抽象方法的类一定是抽象类。
    • 抽象类的子类,必须重写父类中的所有抽象方法,否则编译无法通过,除非子类也是抽象类。

7.接口

接口就是一种公共的规范标准。

接口是一种引用数据类型,最重要的内容就是其中的抽象方法。

  • 定义
    public interface 接口名称{
        // 接口内容
        // 如果是java7,那么接口中可以包含常量和抽象方法
        // 如果是java8,还可以额外包含默认和静态方法
        // 如果是java9,还可以额外包含私有方法
    }

     

  • 接口中的抽象方法
    • 接口中的抽象方法,修饰符必须是两个固定的关键字:public abstract。
    • 这两个关键字的修饰符,可以选择性省略。
    • 方法的三要素可以随意定义。
  • 接口方法的使用
    • 接口不能直接使用,必须有一个实现类来实现该接口。
      public class 实现类 implements 接口名称{
      
      }

       

    • 接口的实现类必须覆盖重写实现
      • 接口中的所有抽象方法,如果实现类并没有覆盖重写接口中所有抽象方法,那么这个实现类自己就必须是抽象类。
    • 创建实现类的对象,进行使用。
  • 接口中的默认方法
    • 定义
      public default 返回值类型 方法名称(参数列表){
          方法体
      }

       

    • 备注
      • 接口中的默认方法,可以解决接口升级问题。
      • 接口中的默认方法,可以通过接口实现类对象,直接调用
      • 接口中的默认方法,可以被接口实现类进行覆盖重写
  • 接口中默认方法使用
    public interface MyInterface{
        public abstract void method1();
        public default void method2(){
        
        }
    }

     

  • 接口中的静态方法
    • 格式
      public static 返回值类型 方法名称(参数列表){
          方法体
      }

       

    • 使用
      • 不能通过接口实现类的对象类调用接口中的静态方法。
      • 通过接口名称,直接调用其中的静态方法。
  • 接口中的私有方法
    • 普通私有方法:解决多个默认方法之间重复代码问题。
      private 返回值类型 方法名称(参数列表){}

       

    • 静态私有方法:解决多个静态方法之间重复代码的问题。
      private static 返回值类型 方法名称(参数列表){}
  • 接口的常量
    • 格式
      public static final 数据类型 常量名称 = 数据值;

       

    • 注意
      • 一旦使用final关键字,说明不可变。
      • 接口中的常量,必须进行赋值。
      • 接口中常量的名称,使用完全大写的字母,用下划线进行分割。
  • 使用接口的注意事项
    • 接口是没有静态代码块或者构造方法的。
    • 一个类的直接父类是唯一的,但是一个类可以实现多个接口。
      public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB{
          覆盖重写所有的抽象方法
      }

       

    • 如果实现类所实现的接口中,存在重复的抽象方法,那么只需覆盖重写一次即可。
    • 如果实现类没有覆盖重写所有接口中的所有抽象方法,那么实现类就必须是一个抽象类。
    • 如果实现类所实现的多个接口中,存在重复的默认方法,那么实现类就一定要对冲突的默认方法进行覆盖重写。
    • 一个类如果直接父类当中的方法和接口中的默认方法产生了冲突,优先使用父类当中的方法。

8.static关键字

  • 定义

一旦使用static关键字,那么内容就不是属于自己,而是属于类的,共享一份。

  • static关键字修饰成员变量

成员变量一旦使用static关键字,那么内容就不是属于自己,而是属于类的,共享一份。

  • static关键字修饰成员方法
    • 成员方法一旦使用static关键字,那么内容就不是属于自己的,而是属于类的。
    • 如果没有static关键字,那么必须首先创建对象,然后通过对象才能使用它。
    • 如果没有static关键字,推荐使用类名称进行调用。
    • 静态变量:类名称.静态变量。
    • 静态方法:类名称.静态方法();。
  • 注意事项
    • 静态不能直接访问非静态:因为内存当中先有的静态,后有的非静态。
    • 静态方法中不能有this:this代表当前对象,通过谁调用,谁就是当前对象。
  • 内存位置
    • static修饰的变量,存放在方法的静态区。
  • 静态代码块
    • 定义
      public class 类名称{
          static{
              静态代码块内容
          }
      }

       

    • 特点
      • 当第一次用到本类的时候,静态代码块执行唯一的一次。
      • 静态内容总是优先于非静态,所以静态代码块比构造先执行
    • 用途
      • 同于一次性地对静态变量进行赋值。
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值