Java基础（二）

大狗晋

已于 2022-06-28 20:56:37 修改

阅读量4.1k

点赞数 4

文章标签：大数据

于 2022-06-25 19:17:26 首次发布

本文链接：https://blog.csdn.net/weixin_52957373/article/details/125448435

版权

1.面向对象

面向对象(OOP)就是Java语言的基础，也是Java语言的重要特性。面向对象的概念：生活中的一切事物都可以被称之为对象，生活中随处可见的事物就是一个对象，我们可以将这些事物的状态属性以及行为特征提取并出来，并以固定的形式表示。

Java语法基础

标识符： 用来标识类名、对象名、变量名、方法名、类型名、数组名、文件名的有效字符序列。

合法的标识符：

由字母、数字、下划线“_”、美元符号“$”或者“￥”组成，并且首字符不能是数字。
不能把java关键字和保留字作为标识符。
标识符对大小写敏感，不能包含空格。

关键字：Java语言中已经赋予了特定含义的

保留字：const、goto，Java版本中尚未使用，但以后版本可能会作为关键字使用

变量：程序运行期间可以被改变的量。在程序中使用变量，必须先创建它并为它取一个名字，并且指明它能够存储信息的类型，这称为“变量声明”，也叫容器的创建。

变量的使用：

变量的声明：数据类型变量名;
变量的赋值：变量名 = 数据;
变量的操作：放入打印语句进行输出或者进行运算

Java 中的注释有三种：

单行注释：以 // 开头
多行注释：以 /* 开头 / 结尾
文档注释：/*文本内容*/

数据类型

基本数据类型（8个），也称原始数据类型：

引用数据类型（3种）：数组、类、接口

类型转换：

自动类型转换，也叫隐式转换
强制类型转换，也叫显式转换
点此处链接(57条消息) java 各种数据类型的互相转换_兔老大RabbitMQ的博客-CSDN博客

运算符

运算符：一种特殊符号，用以表示数据的运算、赋值和比较数与整数

运算符分类：算术运算符、赋值运算符、比较运算符、逻辑运算符、三元运算符

1.算术运算符
最基本的 + 、-、*、/、% 、自增 ++、自减 --。
2.赋值运算符
=，+=，*=，-=，/=，%=
3.比较运算符
>,<,<=,>=,==,!=
4.逻辑运算符
&&,||,!
5.三元运算符
条件表达式b?x:y;，先计算条件b，然后进行判断。如果b的值为true，计算x的值，运算结果为x的值；否则，计算y的值，运算结果为y的值。

Java流程控制语句

选择结构

if语句：if(条件表达式){ 一条或多条语句 };

if else语句：if(条件表达式) {语句块1} else {语句块2}......
if多分支语句: if(条件表达式) {语句块1} else if{语句块2}else if{语句块2}.....
switch开关语句：switch(x){

case a:

语句1;break;

case b:

语句2;break;

......

}

循环结构

在程序中当要重复性的做某项工作时可以使用循环语句，包括：for循环、while循环、do…while循环。

for循环语句：for(初始状态;循环条件;迭代语句){循环代码}
while循环语句：while(循环条件){循环代码}
do…while循环语句：do{循环代码}while(循环条件)； do...while循环是先执行循环体内的代码后判断循环条件

流程跳转语句：break,continue

break：在switch中结束case条件判断，在循环体中结束循环
continue：作用在循环体中，结束循环体的本次循环，而进入下次循环

以上循环体与c语言相似，具体使用方法参考c

数组

数组是数据的集合，一个容器，用来存储任何类型的数据，包括原始数据类型和引用数据类型，但是一旦指定了数组的类型之后，就只能用来存储指定类型的数据。

数组声明的三种方式：

数据类型[] 数组名 = new 数据类型[长度];
数据类型[] 数组名 = {数据,数据,…,数据};
数据类型[] 数组名 = new 数据类型长度[] {数据,数据,…,数据};

一维数组：

数组变量的声明：
语法：数据类型[] 数组名;如：int[] num; double[] d; String[] str;
数组对象的创建：
语法：数组名 = new 数据类型[长度];，如：num = new int[4];，数组声明其长度后不可改变

//数据类型[] 数组名称= new 数据类型[长度];
	int [] arry=new int[5];

赋值：
语法：数组名[下标] = 数据;，如：num[0] = 3;

int [] arry=new int[5];//定义一个长度为5的数组
	Scanner sc=new Scanner(System.in);
	for(int i=0;i<5;i++) {//遍历数组对数组进行赋值
		int num=sc.nextInt();
		arry[i]=num;
	}

数组元素的使用及遍历：
语法：数组名[下标]，获取指定下标是数据。

int [] arry=new int[5];//定义一个长度为5的数组
	Scanner sc=new Scanner(System.in);
	for(int i=0;i<5;i++) {//遍历数组对数组进行赋值
		int num=sc.nextInt();
		arry[i]=num;
	}

for(int j=0;j<arry.length();j++){//遍历数组
   System.out.println(arry[i]);
    }

二维数组：

数组变量的声明：
语法：数据类型[][] 数组名;，如：int[][] num;double[][] d;String[][] str;
数组对象的创建：
语法：数组名 = new 数据类型[外长度][内长度];如：num = new int[4][3];数组声明其长度后不可改变
赋值：
语法：数组名[外下标][内下标] = 数据;，如：num[0][0]= 3;
数组元素的使用及遍历：
语法：数组名[外下标][内下标]，获取指定下标是数据。）

二维数组与一维数组类似，代码不做展示，了解看(57条消息) Java数组（二维数组）_白巧克力x的博客-CSDN博客_java 二维数组https://blog.csdn.net/weixin_52122271/article/details/114400651?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522165615332516782389414053%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=165615332516782389414053&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-114400651-null-null.142%5Ev21%5Epc_rank_34,157%5Ev15%5Enew_3&utm_term=java%E4%BA%8C%E7%BB%B4%E6%95%B0%E7%BB%84&spm=1018.2226.3001.4187

用户交互 Scanner

基本语法：Scanner sc=new Scanner(System.in);

输入字符串、整数：代码展示如下：

package com.study;
//导包
import java.util.Scanner;
// 使用键盘录入
public class Study02 {
	public static void main(String[] args) {
		//获得扫描器对象
		Scanner sc = new Scanner(System.in);      //创建Scanner对象      
		System.out.println("请输入你的姓名：");    
		String name=sc.next();                    //输入字符串
		System.out.println("请输入你的年龄：");	
		//调用 sc对象的功能等待接收用户输入的数据
		int age=sc.nextInt();                     //输入整数
		System.out.println("age is；" +age+"\n"+"name is");
		
	}
}

输出结果：

请输入你的姓名：
li
请输入你的年龄：
12
age is；12
name is

注意：next():获取输入的字符串，但不能得到带有空格的字符串，不能获得空白

1、nextLine():获取输入的字符串
next()以Enter为结束符，可以获得空白
2、hasNexLinet()：判断是否还有输入的数据

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); //创建一个Scanner对象
        System.out.println("使用nextLine方式接受：");
        if(scanner.hasNextLine()){ //判断是否输入字符串
            String str = scanner.nextLine();
            System.out.println("输入的内容为：" + str);
        }
        scanner.close();
    }

输出结果：


    键盘输入内:hello world
    输出结果:hello world

对象与类

对象：客观存在能够相互区分的个体，比如这辆汽车、这个人、这间房子、这张桌子、这株植物、这张支票、这件雨衣。概括来说就是：万物皆对象。

类：若干具有相同属性和行为的对象的群体或者抽象，类是创建对象的模板，由属性和行为两部分组成

类是对象的概括或者抽象，对象是类的实例化。

类的声明

[修饰符] class 类名{//类的声明部分
	[成员变量]
	[成员方法]
}

成员变量的声明：[修饰符] 数据类型变量名 [= 初始值];

成员方法的声明：

[修饰符] 返回值类型 方法名([数据类型 参数名,……]){
	//方法体，该方法完成的功能代码
}

构造器的声明：

[修饰符] 构造器名([数据类型 参数名,……]){
  //构造器完成的功能代码
}

注意：
①构造器名必须和类名一致
②构造器没有返回值类型
③任何类都含有构造器。如果没有显式地定义类的构造器，
④则系统会为该类提供一个默认的无参的构造器。一旦在类中显式地定义了构造器，系统就不会再为这个类提供默认的构造器了。

类的使用

类变量的声明：类名对象名;
类对象的创建，赋值给变量：对象名 = new 构造器([参数列表]);
对象属性的赋值：属性：对象名.属性名、对象名.属性名 = 数据;
属性和方法的调用：属性：System.out.println(对象名.属性名);方法：对象名.方法名();

成员变量与局部变量：

成员变量：声明在类中方法体之外、可以有缺省值、可以使用修饰符。作用域：整个类
局部变量：声明在方法体或代码块中、没有缺省值、只能使用final修饰。作用域：当前方法体

参数：参数的本质是特殊的局部变量，只能定义在方法的小括号中

重载

方法的重载OverLoading： 同一个类中定义了多个方法名相同而参数不同的方法

重载在同一个类中，方法名相同，参数不同（参数的个数、顺序、类型不同）

构造器的重载：

class Person{
	private String name;
	private int age;
public	Person(){
		System.out.println("父类无参构造");
	}
		public Person(String name,int age) {
			this.name=name;
			this.age=age;
		}
        public Person(int age){//重载函数其 函数名不变，参数的类型 顺序 数量 不同
            this.age=age;
    }

方法的返回值类型：

无返回值类型：void，return;//结束方法体
有返回值类型为：数据类型(基本数据类型、引用数据类型)，return 数据;//结束方法体，并且返回一条数据

关键字

this关键字：

this是一种特殊的引用，指向当前对象

this的两种使用方法：
如果发生局部变量和成员变量命名冲突时，可以通过this.成员变量名的方式区分成员变量和局部变量。

一个构造方法中需要调用本类的另一个构造方法，可以通过this()的方式调用，但this()必须要书写在第一行。

static关键字：

静态变量： 使用static修饰的成员变量叫做静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。static成员变量的初始化顺序按照定义的顺序进行初始化。

静态方法： 使用static修饰的成员方法叫做静态方法，静态方法可以不依赖于任何对象进行访问（对于静态方法来说，是没有this的），由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。

调用格式：类名.静态变量名，类名.静态方法名()

静态内部类（static 修饰类的话只能修饰内部类）： 静态内部类与非静态内部类之间存在一个最大的区别: 非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围类，但是静态内部类却没有。没有这个引用就意味着：1. 它的创建是不需要依赖外围类的创建。2. 它不能使用任何外围类的非 static 成员变量和方法。

静态代码块：
是一个以static为前导的代码块，一般用于为类的工作做一些初始化工作，如初始化一些静态变量。一个类中可以有许多静态初始化块，并且它们可以出现在类体的任何地方。运行时系统会保证静态初始化块会按照它们在源代码中出现的顺序被调用

static块可以用来优化程序性能：因为它只会在类加载的时候执行一次

使用方式：
super.属性名、super.方法名();用于在子类中调用父类被隐藏的同名实例变量
super([参数列表])用于在子类的构造方法中调用父类的构造方法

每一个子类的构造方法在没有显示调用super()系统都会提供一个默认的super()，super()必须是构造器的第一条语句

final关键字:

final 关键字，意思是最终的、不可修改的，最见不得变化，用来修饰类、方法和变量，具有以下特点：

修饰类：类不能继承，final 类中的所有成员方法都会被隐式的指定为 final 方法；
修饰符变量：该变量为常量，，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能让其指向另一个对象。
修饰符方法：方法不能重写

访问修饰符
访问修饰符对成员变量和成员方法的访问限定

Java的三大特性

封装

封装指隐藏对象的状态信息（属性），不允许外部对象直接访问对象的内部信息（private实现）。但是可以提供一些可以被外界访问的方法来操作属性。

将类中成员变量private，提供public的get和set方法来控制属性的存取动作，以保证对私有属性操作的安全性：

继承

继承extends：多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承单独的那个类即可。多个类可以称为子类，单独这个类称为父类或者超类。

基本语法：

[修饰符] class 子类名 extends 父类名{
   类体部分
}

继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的属性或方法（对父类进行扩展），也可以拥有父类的属性和方法，并且通过自己的方法再次实现父类的方法（重写）。通过使用继承，可以快速地创建新的类，可以提高代码的重用，程序的可维护性，节省大量创建新类的时间，提高我们的开发效率。

Java只支持单继承，不支持多继承。一个类只能继承一个父类，不可以继承多个父类。Java支持多层继承。Java继承了父类非私有的成员变量和成员方法，但子类是无法继承父类的构造方法。

方法的重写：
子类从父类继承的某个实例方法无法满足子类的功能需要时，需要在子类中对该实例方法进行重新实现，这样的过程称为重写。

package study;

public class Test {
public static void main(String[] args) {
	Li l=new Li();//创建Li类对象
	l.sleep();//调用Li的sleep()方法
	}
}
 class Li extends Person{//继承Person类
public void sleep() {//子类重写sleep()方法
	System.out.println("Li 要睡觉");
	}	
}
class Person{
public void sleep() {//Person类的sleep()方法
	System.out.println("人都要睡觉");
	}
}

运行结果：

Li 要睡觉

方法重写的前提：继承，子类的修饰符大于等于父类，方法名、参数列表、返回值类型必须相同

多态

多态：一种事物的多种形态。

多态的前提：继承、重写、向上转型

通过多态可以提高代码的可重用性，降低模块之间的耦合度。

抽象类

抽象类的概念：
Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。如：Shape类计算周长和面积的方法无法确定，那么就可以将这样的方法声明为抽象的，以便在具体的子类中进行实现。

抽象类的声明：[修饰符] abstract class 类名 [extends 父类名]{类体}
抽象方法的声明：[修饰符] abstract 返回值类型方法名([参数列表]);
因为抽象方法无法确定具体执行的功能，所有抽象方法没有方法体，需要在小括号后加上分号
抽象类和普通类除了使用abstract修饰外和普通的类相似，抽象类中可以没有抽象方法，但是一旦某个有抽象方法，那么这个类必须被声明为抽象类。

抽象类的使用：
因为抽象类不是一个具体的类，所以无法实例化，但是抽象类可以用于声明变量
抽象类可以被继承，在子类中实现抽象类的所有抽象方法，以达到抽象类的具体化

接口

在Java中接口不仅仅是程序开发过程中“约定”，更是更加抽象化的抽象类。

接口的声明语法：[修饰符] interface 接口名{[常量];[抽象方法];
接口实现的语法：[修饰符] class 类名 [extends 父类名] [implements 接口1,接口2,……]{类体部分}

一个类可以实现多个接口，从而解决了Java单继承的缺点。
接口的作用：

提高程序的重用性
提高程序的可扩展性
降低程序的耦合度
实现了多继承

异常：

1.异常：在Java语言中，将程序执行中发生的不正常情况称为“异常”。 (开发过程中的语法错误和逻辑错误不是异常)
2.Java程序在执行过程中所发生的异常事件可分为两类：
①Error：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError和OOM。一般不编写针对性的代码进行处理。
②Exception: 其它因编程错误或偶然的外在因素导致的一般性问题，可以使
用针对性的代码进行处理。例如：空指针访问、试图读取不存在的文件、网络连接中断、数组角标越界。

几种异常：

java.lang.Error:一般不编写针对性的代码进行处理。
java.lang.Exception:可以进行异常的处理
编译时异常(checked)
IOException
FileNotFoundException
ClassNotFoundException
运行时异常(unchecked,RuntimeException)
NullPointerException
ArrayIndexOutOfBoundsException
ClassCastException
NumberFormatException
InputMismatchException
ArithmeticException

大狗晋

关注

4
点赞
踩
14

收藏

觉得还不错? 一键收藏
打赏
1
评论
Java基础（二）

1.面向对象标识符：用来标识类名、对象名、变量名、方法名、类型名、数组名、文件名的有效字符序列。合法的标识符：关键字：Java语言中已经赋予了特定含义的保留字：，Java版本中尚未使用，但以后版本可能会作为关键字使用变量：程序运行期间可以被改变的量。在程序中使用变量，必须先创建它并为它取一个名字，并且指明它能够存储信息的类型，这称为“变量声明”，也叫容器的创建。变量的使用：Java 中的注释有三种：基本数据类型（8个），也称原始数据类型：引用数据类型（3种）：数组、类、接口类型转换：运算符：一种特殊
复制链接

扫一扫