JavaSE

用户135171718391
148 阅读9分钟

Java语言概述

  • 是一种面向对象的编程语言。
  • JRE与JDK
    JDK包含JRE包含JVM
  • JAVA项目的编译过程：
    把写的.java文件交给-->编译工具(javac.exe)-->生成一个字节文件(.class)-->运行工具(java.exe)

JDK安装

JDK安装步骤

安装idea

Java基础概念

  • Java文件(类文件)：主要由类组合而成，每个java文件都有类构成(可以有多个类), 每个类中有多个方法
  • 第一个程序(HelloWord.java)
// 一个java文件中，只有一个主函数(main方法/主方法)
public class HelloWord { // 类名与文件名一致
    public static void main(String[] args) {
        System.out.println("Hello World"); // println 自带换行功能
                                           // print 不换行
    }
}

image.png

  • 注释
单行注释 
    // 注释内容
多行注释
    /*注释内容*/
  • Java命令规则
类名：使用名词, 大驼峰 (XxxYyyZzz)
方法名：小驼峰 (xxxYyyZzz)
包名：公司域名倒写+项目的名字+项目模块的名字 (com.juejin.test.module)
  • 常见错误
    • 1.类名和文件不一致，导致无法运行。
    • 2.大小写字符写错。class写错Class, System写成了system
    • 3.类名格式有问题 暂时全部使用英文
    • 4.main方法格式错误 public static void main(String[] args){}
    • 5.大括号匹配不正确
    • 6.缺少;
    • 7.标点符号出错。
    • 8.引号使用错误，使用成中文全角引号

idea快捷建

  • 格式化：ctrl+shift+f

Java主类结构

  • 变量: 全局变量(成员变量) 与 局部变量
class Person { // Java中的类由 属性(变量) 和方法(函数) 组成
     // 类型 变量名称 = 值;
    int age = 10; // 全局属性
    public void setName() { // 方法 ，函数
        boolean flag = true; // 局部属性
        System.out.println(age);
    }
}

通常将类的属性称之为类的全局变量(成员变量)。
将方法中的属性称之为局部变量。
全局变量声明在类体中。
局部变量声明在方法体中。 全局变量和局部变量都有各自的应用范围。

数据类型

image.png

字符串类型：String s = "hello"; 可以存储多个字符，用双引号

变量

image.png

  • 先声明变量并赋值，然后才能使用

类型转换

  • 在Java中，不同类型之间在一定条件下是可以相互转换的
  • 类型转换
    • 自动类型转换(隐式转换)
    • 强制类型转换(显式转换)
  • 自动类型转换

image.png

  • 强制类型转换
语法：数据类型1 变量的名字1 = (数据类型1)变量的名字2;

double d = 3.64d;
int i = (int)d;

转义字符

Math类

image.png

对于静态(static)的方法和属性，可以直接来使用
    调用方法：类名.方法名();
    调用属性：类型.属性;
基本数据类型-转义字符

一种特殊的字符变量】它以反斜线”\”开头，后面跟一个或多个字符，转义字符具有特定的含义，不同于字符原有的意义，故称“转义”。例如printf函数的格式串中用到的“\n”就是一个转义字符，意思是“回车换行”。

'引号字符
\反斜杠字符 \t垂直制表符， 将光标移到下一个制表符的位置
\r 回车
\n 换行

变量与常量

标识符和关键字

  • 标识符可以简单地理解为一个名字，用来标识类名、变量名、方法名、数组 名、文件名的有效字符序列，
  • 标识符: 由任意顺序的字母、数字、下划线(_)和美元符号($)组成,第一个字符不能是数字开头不能使用关键字
关键字

就是iava语言中已经被赋予特定意义的一些单词，不可以把这些字作为标识符来使用。如: int, public , if, short, void等

常量

常量:在程序执行过程中，其值不能被改变的量叫常量，通常也被称为“final变量”。常量在整个程序中只能被赋值一次。 声明常量的标准语法如下:
final 数据类型常量名称 = 值
常量名通常使用大写字母。

例子:声明常量
final double Pl=3.1415926D;  
final boolean BOOL=true;

注意:当定义final变量属于“成员变量(全局变量)”时，必须在定义时就设定它的初值，否则将会产生编译错误。

运算符

  • 算数运算符

  • 赋值运算符

  • 比较运算符

  • 逻辑运算符

  • 算术运算符 image.png

  • 自增运算符 image.png

  • 注1:不论++在前或者在后，++和变量都是一个整体，不可分割。如果变量在后，则整个式子取变量+1之后的值。如果变量在前，则整个式子去变量+1之前的值。

  • 注2:自减--与自增++道理相同。

  • 赋值运算符 image.png =为基本的赋值运算符，意思是把=右边的赋值给=左边的。是其他 运算符的基础。

  • 比较运算符 image.png 比较运算符的结果都是boolean型，也就是要么是true，要么是false。

  • 逻辑运算符 image.png

  • 逻辑运算符用于连接布尔型表达式。在Java中不可以写成3<x<6，应该写成x>3&x<6。

  • 表达式:用运算符连接的式子。布尔型表达式就是运算结果为 boolean类型的表达式。

  • &和&&的区别:
    单&时(&)，左边无论真假，右边都进行运算;
    双&时(&&)，如果左边为假，右边不参与运算。(短路运算)

  • |和||的区别:
    单|时(|)，左边无论真假，右边都进行运算;
    ·双||时(||)，如果左边为真，右边不参与运算。

  • ∧:
    两边相同时，结果为假。
    两边不同时，结果为真

  • 三目运算符

布尔表达式1 ? 表达式2 :表达式3 
System.out.println((4<5)?'a':'b');

通常情况下，表达式1是布尔表达式用干描述条件表达式中的条件,表达式2和表达式3可以是常量变量或表达式

Java流程控制语句

if语句(条件判断结构)
if(布尔表达式){
    // 当表达式结果为true时，执行这里的内容（语句块）
}

if(布尔表达式){
    // 当表达式结果为true时, 执行这里的内容
}else{
    // 结果为false时，执行这里的内容
}

// 例子
if(i > 10) {
    System.out.println("Hello")
}

if(i > 10) {
    System.out.println("Hello")
}else{
    System.out.println("say Hello")
}

if(i > 10) {
    System.out.println("Hello")
}else if(i == 10){
    System.out.println("say Hello")
}else {
   System.out.println("say Hello World") 
}
Scanner类
输入：Scanner类
1. 根据Scanner类生成对应的对象
   Scanner sc = new Scanner();
   数据类型 变量名 = 值;
2. 根据对象来调用输入的方法
   int i = sc.next();
导包
import 包名
switch多分支语句
switch(表达式) {
    case 常量表达式1:
        语句块
        break;
    case 常量表达式2:
        语句块
        break;
    ....
    case 常量表达式n:
        语句块n
        break;
    default:  // default不是必须的，是可选的
        语句块n+1
}

break: 一旦程序遇到break, 整个程序就终止
continue: 跳转到程序开始的地方

  String str = "前锋教育" ;
  switch (str) {
      case "前锋":
          System.out.println("wwww.1000phone.com");
          break;
      case "前锋1":
          System.out.println("testing");
          break;
      case "前锋2":
          System.out.println("前锋2");
          break;
      default:
          System.out.println("没有");
  }
while语句
while(条件表达式) {
    // 循环体
}

int i = 1;
while(i <= 100) {
    System.out.println(i);
    i++;
}
  • 通过while循环语句将整数1-10相加，并打印出来
int x = 1;
int sum = 0;
while(x <= 10) {
    sum = sum + x;
    x++;
}
System.out.println("sum="+sum)
do-while
do
    循环体语句
while(表达式);

// 先执行循环体，后判断表达式；
// 至少执行一次循环
// do-while可转换成while结构
for循环
for(初始化语句; 循环判断语句; 循环变化语句){
    循环体
}
  • 输出 1 - 100之间的偶数
for(let i = 1; i <= 100; i++) {
    if(i%2 == 0) {
        System.out.println(i);
    }
}
嵌套循环
// 1. 先执行外层循环，然后执行内层循环
// 2. 外层循环执行一次，内层循环就执行一遍
打印下面的效果
*****
****
***
**
*

for(int i = 1; i <= 5; i++) {
    for(int j = 5; j >= i; j--) {
        System.out.println("*");
    }
    System.out.println();
}

数组

  • 数组是具有相同数据类型的一组数据的集合
  • java中，可将数组看作一个对象
  • 下标：数组的下标是从0开始的
  • 元素：指的是数组中存储的数据
一维数组
  • 声明一维数组(语法)
// 第一种
数组元素类型 数组名字[];
int arr[]; // int类型的 名字是arr 的数组

// 第二种
数组元素类型[] 数组名字;
int[] arr; // int类型的数组，名字是arr

数组类型决定了数组元素的类型
数组名字必须为一个合法的标识符
[]表明这是一个数组类型变量
单个[]表示这是一个一维数组

  • 分配空间一维数组(分配空间)
数组名字 = new 数组元素类型[数组元素的个数]

int arr[];  // 1. 先声明一个int类型 名字是arr的数组
arr = new int[6]; // 2. 给这个名字叫arr的数组分配空间
// 数组元素的个数：指定数组中变量的个数字, 即数组的长度
  • 声明的同时为数组分配内存
数组元素类型 数组名[] = new 数组元素类型[数组元素的个数];
数组元素类型[] 数组名 = new 数组元素类型[数组元素的个数];
int month[] = new int[12];
int[] month = new int[12]
  • 初始化一维数组
int arr[] = new int[]{1,2,3,4};
int arr2[] = {1,2,3,4};

// 查找下标为2的元素
System.out.println(arr[2])
  • 遍历数组
int arr2[] = new int[]{1,2,3,4,5};
for(int i = 0; i < arr2.length; i++) { // length指的是数组里有多少个元素
   System.out.println(arr2[i])
}
// java.lang.ArrayIndexOutOfBoundsException 数组下标越界

二维数组的创建及使用

  • 先声明，然后再用new运算符进行内存分配
// 第一种方式
数组元素类型 数组名[][];
int arr[][];

// 第二种方式
数组元素类型[][] 数组名;
int [][] arr;
  • 给声明的数组赋值
数组名 = new 数组元素类型[m][n];
arr = new int[2][2];
  • 声明并直接赋值
数组元素类型 数组名[][] = new 数组元素类型[m][n];
数组元素类型[][] 数组名 = new 数组元素类型[m][n];

int arr[][] = new int[2][3];
int[][] arr = new int[2][3];
// 2 指的是arrs里边存储了2个数组
// 3 指的是arrs中存储了这个2个数组，每个数组的大小都为3
  • 初始化二维数组
int[][] arr = {{1,2,3},{4,5},{3}}
// 查找下标为arr[1][1]
System.out.println(arr[1][1])
  • 二维数组定义方式扩展
数据类型[][] 数组名 = new 数据类型[m][];
m指的是这里边存储了m个数组
int[][] arr = new int[3][]
  • 二维数组遍历
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
for(let i = 0; i< arr.length; i++){
    for(let j = 0; j< arr[i].length; j++){
        System.out.println(arr[i][j]);
    }
}

面向对象

  • 对象有属性(静态部分)和方法(动态部分);
[权限修饰符] class 类名{
    [权限修饰符] 数据类型 变量名;  // 属性
    [权限修饰符] 数据类型 方法名([参数类型 参数名称]){ // 方法 有返回值的，可以有参数，也可以无参数
         return 值;
    }
    [权限修饰符] void 方法名([参数类型 参数名称]){ // 方法 无返回值的，可以有参数，也可以无参数
 
    }
    
    // setter方法 --设置属性值
    public void set属性名(数据类型 属性名){ // 形参
        this.属性名 = 属性名;
    }
    // getter方法 --获取属性值
    public 数据类型 get属性名(){
        return 属性名;
    }
}

public class Animal{ // 类似工厂
    public String color; // 属性 成员变量
    public int weight;
    String name;
    
    public void eat(){
        int a = 1; // 局部变量
        System.out.println("吃");
    }
    // set方法
    public void setColor(String c){ // 形参
        this.color = c // this是将参数值赋值为类的成员变量
    }
    // get方法
    public String getColor() {
        return color
    }
}
// 在一个java文件中，public 修饰的类，只能有一个(一般是主类)

Animal cat = new Animal(); // new 理解为造动物的过程
// 类名 对象名 = new 类名();
// new 实例化出类的对象

// 通过对象调用属性和方法
// 调用属性: 对象名.属性名
cat.name = "小花";
// 调用方法：对象名.方法名();
cat.eat();

Animal dog = new Animal();
dog.name = "小明";
dog.eat();

cat.setColor("暗黄色"); // 实参
cat.getColor() // "暗黄色"
权限修饰符

  • public 对外公开 所有是类都能访问

  • protected 受保护的 子类及其同一个包中的类可以访问

  • 默认的 没有访问修饰符, 只能向同一个包中的类公开

  • private 私有的 只有类本身可以访问, 不对外公开

  • abstract 可以用来修饰类和成员方法，用该修饰符修饰的类表示抽象类，用该修饰符修饰的方法表示抽象方法

面向对象的三个特点
  • 封装，继承，多态
avatar
文章
阅读
粉丝