Java基础课程概述【笔记】

最新推荐文章于 2023-03-17 22:13:05 发布

和你在一起^_^

最新推荐文章于 2023-03-17 22:13:05 发布

阅读量598

点赞数

分类专栏：面试准备 Java基础

本文链接：https://blog.csdn.net/weixin_42462804/article/details/106204213

版权

面试准备同时被 2 个专栏收录

55 篇文章 6 订阅

订阅专栏

Java基础

29 篇文章 0 订阅

订阅专栏

文章目录一瞥

Java基础课程概述
面向对象的特征：封装、继承、多态
Java基础课程体系

Java基础课程概述

第一部分：编程语言核心结构
主要知识点：变量、基本语法、分支、循环、数组、 …
第二部分： Java面向对象的核心逻辑
主要知识点： OOP、封装、继承、多态、接口、 …
第三部分：开发Java SE高级应用程序
主要知识点：异常、集合、 I/O、多线程、反射机制、网络编程、 ……
第四部分：实训项目
项目一：家庭收支记账软件
项目二：客户信息管理软件
项目三：开发团队人员调度软件
附加项目一：银行业务管理软件
附件项目二：单机考试管理软件

0.标识符，变量

标识符
Java 的标识符是由字母、数字、下划线_、以及美元符$组成，但是首字母不可以是数字。Java 标识符大小写敏感，长度无限制，不能是 Java 中的关键字。命名规则：要见名知意！

u  变量要首字母小写和驼峰原则；

u  常量的单词字母要全部大写，若有两个以上的单词组成，就用下划线"_"进行连接;

u  类名要首字母大写和驼峰原则；

u  方法名要首字母小写和驼峰原则，如showRun（）

通过变量来操纵存储空间的数据，变量就指代这个存储空间。空间的位置是确定的，但是里面存放的值不确定。

局部变量
存在于栈内存的方法中，生命周期伴随所属区域始终，使用前必须先声明和初始化
成员变量(实例变量)
存在于堆内存的对象中，从属对象，生命周期伴随对象始终，自动初始化、有默认初始值
静态变量(类变量)
存在于方法区，用static修饰，从属类，生命周期伴随类始终，自动初始化、有默认初始值

1.java中的数据类型：数据的单位

基本数据类型：程序里面自带的数据类型
布尔类型：boolean *：true/false
字符类型：char    *: Unciode编码 -》 不区分中英文
		统一的都是2个字节 = 16个位
		取值范围：0-65535
		char x = 'a';
		char y = '男';
		char z = 55;//范围：0-65535
整数类型：byte short int long -> int*  
浮点类型：float double -> 小数  double*

	重点：boolean  char  int/long double
	boolean -> 判断
	char -> 一个字、一个字母
	int/long -> 整数
	double -> 小数

2.基本数据类型之间的转换：

基本数据类型存储在栈内存中，而它们对应包装类的实例对象存储在栈内存中。

取值范围：小 -》 大
      char
byte  short  int  long  float  double
小的变大的 直接转变
	int x = 45;
	double y = x;
大的变小的 需要强转：
	double x = 45.5;
	int y = (int)x;
	Integer.toString(34);//将34整数变成"34";
	int a =Integer.parseInt("123");
	double b = Double.parseDouble("12.23");
	boolean b =Boolean.parseBoolean("true");
	Integer i = newInteger("123");  
	int num =i.intValue();
	还可以进行进制之间的互换：
	（1）十进制转成其他进制：toBinaryString();二 toOctalString();八 toHexString();十六 
	（2）其他进制转成十进制：arseInt(string,radix);//其中，radix=2,8,16

3.引用数据类型程序员自己开发的数据类型

main:
创建对象：
Student stu = new Student();
对属性赋值：
stu.name = "张三";
stu.gender = '男';
stu.stuId = 12345;
stu.study();//学习
//char x = stu.showGender();
System.out.println(stu.showGender());

main:
Student stu = new Student();
System.out.println(stu.name.length());

class Student{
	String name;//null
	char gender;// 
	int stuId;//0
	
	public void study(){
		System.out.println("学习");
	}
	public char showGender(){
		int x = 45;
		return gender;
	}
}

4.java中的变量：

分类：
成员变量属性实例变量：定义在类体里面
局部变量自动变量：定义在方法体里面

区别：
1：定义的位置不同
2：作用范围不同
	成员变量：依赖于对象存在
	Student stu = new Student();//name gender stuId创建
	局部变量：依赖于方法存在
	stu.XXX();里面的局部变量创建
3：默认值不同：
	成员变量：即使不赋值 也有默认值
	局部变量：没有默认值 要求在使用之前必须先赋值

5.java中的分支/判断：

if else:*****

	if(boolean判断){
		执行语句;
	}else if(boolean判断){
		执行语句;
	}else if(boolean判断){
		执行语句;
	}

	if(x % 2 == 0){
		return "偶数";
	}else{
		return "奇数";
	}
	-》
	if(x % 2 == 0)
		return "偶数";
	return "奇数";

	if(x % 2 == 0){
		return true;
	}else{
		return false;
	}	
	->
	return x % 2 == 0;
	
	只要两个学生的姓名一样就是为相等对象
	public boolean equals(Object obj){
		if(obj == null)return false;
		if(!(obj instanceof Student))return false;
		if(obj == this)return true;

		return this.name.equals(((Student)obj).name));	
	}
	

=====================================
switch case:
	switch(参数){
		case XX : 执行语句;
		case YY : 执行语句;
		default : 执行语句;
	}

	参数只能传某几种数据类型：
		jdk1.0 char byte short int
		jdk5.0 enum
		jdk7.0 String
	
	System.out.println("请选择A/B/C/D");
	Scanner sc = new Scanner(System.in);
	String ABCD = sc.next();
	
	switch(ABCD){
		case "A" : 语法操作1;break;
		case "B" : 语法操作1;break;
		case "C" : 语法操作1;break;
		case "D" : 语法操作1;break;
		default : 语法操作1;
	}

6.java中的循环：

for:
	for(变量初始化;循环条件;循环之后的变化){
				循环执行的代码
	}
	for(int x = 1;x <= 100;x++){
		if(x % 8 == 0){
			System.out.println(x);
		}
	}
while:
	变量初始化;
	while(循环条件){
		执行语句;
		循环之后的变化;
	}
	int x = 1;
	while(x <= 100){
		if(x % 8 == 0){
			System.out.println(x);
		}
		x++;
	}

do while:
	int x = 1;
	do{
		if(x % 8 == 0){
			System.out.println(x);
		}
		x++;
	}while(x <= 100);

7.数组：

基本概念：数组是容器装元素类型相同存储空间连续

int[] data = new int[5];//0 0 0 0 0
int[] data = new int[]{45,77,82,19,90};
int[] data = {56,77,28,99};

得到某一个元素：data[下标]  从0开始
得到数组大小：data.length
	     str.length()
	     list.size()
遍历数组：
for(int x = 0;x < data.length - 1;x++){
	System.out.println(data[x]);
}

for(int x : data){
	System.out.println(x);
}

数组的复制1：
int[] data = {56,77,28,99};
往数组里面添加元素：
int[] temp = new int[data.length+1];//0 0 0 0 0 0
System.arraycopy(data,0,temp,0,4);//56 77 28 99 0
temp[temp.length - 1] = 66;
data = temp;

数组的复制2：
int[] data = {44,55,66,77,88};
data = Arrays.copyOf(data,data.length+1);
数组的复制3：
int[ ] cloneArr=(int[ ])arr.clone( );

数组排序：
自动排序：Arrays.sort(数组对象);
          只能升序   import java.util.*;

手动排序 
（1）冒泡排序：
	int[] data = {56,88,37,40,99};

	for(int x = 0;x < data.length - 1;x++){//次数
		for(int y = 0;y < data.length - 1;y++){//下标
			if(data[y] > daya[y + 1]){
				int z = data[y];
				data[y] = data[y + 1];
				data[y + 1] = z;
			}
		}
	}
（2）选择排序法：从头角标对应的元素开始，和每个元素进行一次比较。第一次内循环后，最值出现在头角标位置

for (int x=0;x<arr.length-1 ; x++){

       for(int y=x+1; y<arr.length; y++){

              if(arr[x]>arr[y]){

                     swap(arr,x,y);}}}
（3）折半查找

public static inthalfSearch (int[] arr,int key){

int min = 0,max =arr.length-1,mid;

while(min<=max){

       mid = (max+min)/2;

       if(key>arr[mid])

              min = mid + 1;

       else if(key<arr[mid])

              max = mid - 1;

              else

                     return mid;

       }

       return -1;}}// 如果要想实现在一个有序的数组里面加入一个元素，要求加入后数组里面的元素任然有有序的。此处应该改成return min

面向对象的特征：封装、继承、多态

8.封装：用private修饰属性和方法

main:
Student stu = new Student();
//stu.name = "";
stu.setName("张三");
System.out.println(stu.getName());

class Student{
	private String name;
	//setter方法修改值
	public void setName(String name){
		this.name = name;
	}

	//getter方法得到值：
	public String getName(){
		return name;
	}
}

9.继承：用extends实现两个类之间的is a的关系

共享代码
class Person{
	String name;
	int age;
	char gender;
}

class Student extends Person{}

10多态：一个对象总有不同的类型去定义它

1：创建对象
       Person x = new Student();

2:放在参数里面解耦
   public void wc(Student stu){XXX}
   public void wc(Teacher tea){XXX}
   public void wc(Doctor x){XXX}

   ->
   public void wc(Person x){}

   -> Object类里面有一个方法判断两个对象能不能视为相等对象
      1.equals(Object obj)

11.方法重载 Overload:

条件？
是否发生在同一个类体中
方法名是否一模一样
参数是否不同【类型不同 个数不同 顺序不同】

String:
substring(int 下标)：该下标截取到最后
substring(int x,int y)：从下标x截取到下标y-1

ArrayList:
remove(int 下标);
remove(Object 元素)

作用
同时满足用户的不同需求

12方法覆盖 Override

条件？
子类在继承得到父类的某些方法之后 不满意 在子类里面重新实现一下

子类权限 >= 父类权限
返回类型
	jdk5.0之前 一模一样
	jdk5.0开始 斜变返回类型
方法签名		一模一样
异常	<= 父类的异常

父类：
protected Object clone(){XXX}
子类：
public Object/Object子类 clone(){}

13.构造方法

每个类都有构造方法 我们不写 系统提供一个默认构造方法
//Student stu = new Student();

Student stu = new Student("张三"，34);
stu.setAge(45);

class Student{
	String name;
	int age;
	public Student(String name,int age){
		this.name = name;
		this.age = age;
	}
	//public Student(){}
}

构造方法的首行：
super():表示要执行本构造方法之前 先去执行父类的构造方法
class Father{
	String name;
	int age;
	public Father(String name,int age){
		this.name = name;
		this.age = age;
	}

	public void showDay(){
		System.out.println("吃饭");
		System.out.println("看电视");
		System.out.println("砍树");
	}
}

class Son extends Father{
	//name  age
	int stuId;
	
	public Son(String name,int age,int stuId){
		super(name,age);//只能放在构造方法的首行 共享父类构造方法的代码
		this.stuId = stuId;
	}
	
	@Override
	public void showDay(){
		super.showDay();//放在普通方法里面任何一行 共享父类普通方法的代码
		System.out.println("打游戏");

	}
}

this():要执行本构造方法之前 先去执行本类的其他的构造方法
class Student{
	String name;
	int age;
	int stuId;//成员变量
	
	public Student(String name,int age){
		this.name = name;
		this.age = age;
	}
	
	public Student(String name,int age,int stuId){
		this(name,age);//放在构造方法首行 共享本类其他构造方法的代码
		this.stuId = stuId;
	}

	public void show(){
		int stuId = 12345;//局部变量
		System.out.println(stuId);
		//this.表示当前调用该方法的对象 没有位置限制
		System.out.println(this.stuId);
	}
}

14.键盘输入方法

1.接收一个字符：System.in.read();
char c=(char)System.in.read();

2.接收一个字符串：BufferedRead类和InputStreamReader类
BufferedReaderbr=new BufferedReader(new InputStreamReader(System.in));
Stringc=br.readLine();

3.接受任意数据：Scanner类
Scanner s=new Scanner(System.in);
System.out.println("请输入你的姓名：");
String name=s.nextLine();
System.out.println("请输入你的年龄：");
int age=s.nextInt();
System.out.println("请输入你的工资：");
float salary=s.nextFloat();
Scanner s=new Scanner(System.in);
System.out.println("请输入你的年龄：");
int age=s.nextInt();
System.out.println("请输入你的姓名：");
String name=s.next();
System.out.println("请输入你的工资：");
float salary=s.nextFloat();
next()和nextLine()的区别：
在java中，next()方法是不接收空格的，在接收到有效数据前，所有的空格或者tab键等输入被忽略，若有有效数据，则遇到这些键退出。
nextLine()可以接收空格或者tab键，其输入应该以enter键结束。

15.访问控制符

使用访问权限符修饰方法/成员变量的可见性

访问控制符
在这里插入图片描述

Java基础课程体系

第1章 Java语言概述
第2章基本语法
第3章数组
第4章面向对象编程(上)
第5章面向对象编程(中)
第6章面向对象编程(下)
第7章异常处理
第8章枚举类&注解
第9章 Java集合
 第10章泛型
 第11章 IO流
 第12章多线程
 第13章 Java常用类
 第14章 Java反射机制
 第15章网络编程
 第16章 Lambda表达式与Stream API
 第17章 Java 9 & 10 & 11新特性在这里插入图片描述

第1章 Java语言概述

软件开发
软件，即一系列按照特定顺序组织的计算机数据和指令的集合。有系统软件和应用软件之分
人机交互方式
 图形化界面(Graphical User Interface GUI)这种方式简单直观，使用者易于接受，容易上手操作。
 命令行方式(Command Line Interface CLI)：需要有一个控制台，输入特定的指令，让计算机完成一些操作。较为麻烦，需要记录住一些命令
常用的DOS命令
dir : 列出当前目录下的文件以及文件夹
md : 创建目录
rd : 删除目录
cd : 进入指定目录
cd… : 退回到上一级目录
cd: 退回到根目录
del : 删除文件
exit : 退出 dos 命令行
 补充： echo javase>1.doc

是SUN(Stanford University Network，斯坦福大学网络公司 ) 1995年推出的一门高级编程语言。
 是一种面向Internet的编程语言。 Java一开始富有吸引力是因为Java程序可以在Web浏览器中运行。这些Java程序被称为Java小程序（applet）。 applet使用现代的图形用户界面与Web用户进行交互。 applet内嵌在HTML代码中。
 随着Java技术在web方面的不断成熟，已经成为Web应用程序的首选开发语言，开发效率
在这里插入图片描述

Java技术体系平台

Java SE(Java Standard Edition)标准版
Java EE(Java Enterprise Edition)企业版
Java ME(Java Micro Edition)小型版
Java Card支持一些Java小程序（Applets）运行在小内存设备（如智能卡）上的平台

从Java的应用领域来分， Java语言的应用方向主要表现在以下几个方面：
• 企业级应用：主要指复杂的大企业的软件系统、各种类型的网站。 Java的安全机制以及它的跨平台的优势，使它在分布式系统领域开发中有广泛应用。应用领域包括金融、电
信、交通、电子商务等。
• Android平台应用： Android应用程序使用Java语言编写。 Android开发水平的高低，很大程度上取决于Java语言核心能力是否扎实。
• 大数据平台开发：各类框架有Hadoop， spark， storm， flink等，就这类技术生态圈来讲，还有各种中间件如flume， kafka， sqoop等等，这些框架以及工具大多数是用Java编写而成，但提供诸如Java， scala， Python， R等各种语言API供编程。
• 移动领域应用：主要表现在消费和嵌入式领域，是指在各种小型设备上的应用，包括手机、 PDA、机顶盒、汽车通信设备等。

java之父James Gosling团队在开发”Green”项目时，发现C缺少垃圾回收系统，还有可移植的安全性、分布程序设计和多线程功能。最后，他们想要一种易于移植到各种设备上的平台。

主要特征

• Java语言是易学的。 Java语言的语法与C语言和C++语言很接近，使得大多数程序员很容易学习和使用Java。
• Java语言是强制面向对象的。 Java语言提供类、接口和继承等原语，为了简单起见，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为implements）。
• Java语言是分布式的。 Java语言支持Internet应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类
库，包括URL、 URLConnection、 Socket、 ServerSocket等。 Java的RMI（远程方法激活）机制也是开发分布式应用的重要手段。
• Java语言是健壮的。 Java的强类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证。对指针的丢弃是Java的明智选择。
Java语言是安全的。 Java通常被用在网络环境中，为此， Java提供了一个安全机制以防恶意代码的攻击。如：安全防范机制（类ClassLoader），如分配不同的名字空间以防替代本地的同名类、字节代码检查。
• Java语言是体系结构中立的。 Java程序（后缀为java的文件）在Java平台上被编译为体系结构中立的字节码格式（后缀为class的文件），然后可以在实现这个Java平台的任何系统中运行。
• Java语言是解释型的。如前所述， Java程序在Java平台上被编译为字节码格式，然后可以在实现这个Java平台的任何系统的解释器中运行。
• Java是性能略高的。与那些解释型的高级脚本语言相比， Java的性能还是较优的。
• Java语言是原生支持多线程的。在Java语言中，线程是一种特殊的对象，它必须由Thread类或其子（孙）类来创建

1.4 Java语言运行机制及运行过程

特点一：面向对象
两个基本概念：类、对象
三大特性：封装、继承、多态
特点二：健壮性
吸收了C/C++语言的优点，但去掉了其影响程序健壮性的部分（如指针、内存的申请与
释放等），提供了一个相对安全的内存管理和访问机制
特点三：跨平台性
跨平台性：通过Java语言编写的应用程序在不同的系统平台上都可以运行。 “Write
once , Run Anywhere”
原理：只要在需要运行 java 应用程序的操作系统上，先安装一个Java虚拟机 (JVM Java
Virtual Machine) 即可。由JVM来负责Java程序在该系统中的运行
在这里插入图片描述
Java两种核心机制
Java虚拟机 (Java Virtal Machine)
垃圾收集机制 (Garbage Collection)

核心机制—垃圾回收

不再使用的内存空间应回收—— 垃圾回收。

在C/C++等语言中，由程序员负责回收无用内存。
Java 语言消除了程序员回收无用内存空间的责任：它提供一种系统级线程跟踪存储空间的分配情况。并在JVM空闲时，检查并释放那些可被释放的存储空间。

垃圾回收在Java程序运行过程中自动进行，程序员无法精确控制和干预。

1.5 Java语言的环境搭建

明确什么是JDK, JRE
下载 JDK
安装 JDK
配置环境变量
path： windows系统执行命令时要搜寻的路径。
验证是否成功： javac java
选择合适的文本编辑器或 IDE 开发

JDK(Java Development Kit Java开发工具包)
JDK是提供给Java开发人员使用的，其中包含了java的开发工具，也包括了JRE。所以安装了JDK，就不用在单独安装JRE了。
 其中的开发工具：编译工具(javac.exe) 打包工具(jar.exe)等
JRE(Java Runtime Environment Java运行环境)
包括Java虚拟机(JVM Java Virtual Machine)和Java程序所需的核心类库等，如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可
在这里插入图片描述

在这里插入图片描述

声明为public的类应与文件名一致，否知编译失败

public static void main(String[] args)

单行注释
格式： //注释文字
多行注释
格式： /* 注释文字 */
注：
对于单行和多行注释，被注释的文字，不会被JVM（java虚拟机）解释执行。
多行注释里面不允许有多行注释嵌套。

Java源文件以“java”为扩展名。源文件的基本组成部分是类（class），如
本例中的HelloWorld类。
Java应用程序的执行入口是main()方法。它有固定的书写格式：
public static void main(String[] args) {…}
Java语言严格区分大小写。
Java方法由一条条语句构成，每个语句以“;”结束。
大括号都是成对出现的，缺一不可。
一个源文件中最多只能有一个public类。其它类的个数不限，如果源文件包含
一个public类，则文件名必须按该类名命名。

面向对象的编程

在这里插入图片描述

面向过程(POP) 与面向对象(OOP)

面向对象的三大特征
封装 (Encapsulation)
继承 (Inheritance)
多态 (Polymorphism)
面向对象： Object Oriented Programming
面向过程： Procedure Oriented Programming
程序员从面向过程的执行者转化成了面向对象的指挥者

**类(Class)**和**对象(Object)**是面向对象的核心概念。

 类是对一类事物的描述，是抽象的、概念上的定义
 对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。
 “万事万物皆对象
 属性：对应类中的成员变量
 行为：对应类中的成员方法

Field = 属性 = 成员变量， Method = (成员)方法 = 函数

对象的创建和使用

创建对象语法：类名对象名 = new 类名();
使用“对象名.对象成员”的方式访问对象成员（包括属性和方法）

//创建对象
Animal xb=new Animal();
xb.legs=4;//访问属性
System.out.println(xb.legs);
xb.eat();//访问方法
xb.move();//访问方法

内存解析堆放对象，栈放变量

在这里插入图片描述

对象的创建和使用：匿名对象

我们也可以不定义对象的句柄，而直接调用这个对象的方法。这
样的对象叫做匿名对象。

如： new Person().shout();

类的成员之一：属性field

在这里插入图片描述
在方法体外，类体内声明的变量称为成员变量。
 在方法体内部声明的变量称为局部变量。

【成员变量】private、 public、 static、 final等
private 不能在外部访问
static 静态，被static关键字修饰的不需要创建对象去调用
final 可以用final修,表示这个不能被继承
【局部变量】不能用权限修饰符修饰，可以用final修,表示这个不能被继承

类的成员之二：方法method

什么是方法(method、函数):
 方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中
也称为函数或过程。
 将功能封装为方法的目的是，可以实现代码重用，简化代码
 Java里的方法不能独立存在，所有的方法必须定义在类里

再谈方法1：方法的重载(overload)

在这里插入图片描述


public class TestOverload {
	public void test(String[] msg){
		System.out.println("含字符串数组参数的test方法 ");
	}
	public void test1(String book){
		System.out.println("****与可变形参方法构成重载的test1方法****");
	}
	public void test1(String ... books){
		System.out.println("****形参长度可变的test1方法****");
	}
	public static void main(String[] args){
		TestOverload to = new TestOverload();
	//下面两次调用将执行第二个test方法
		to.test1();
		to.test1("aa" , "bb");
	//下面将执行第一个test方法
		to.test(new String[]{"aa"});
	}
}

面向对象特征之一：封装和隐藏

我们程序设计追求“高内聚，低耦合”。
 高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
 低耦合：仅对外暴露少量的方法用于使用。
 隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

类的成员之三：构造器(或构造方法)

在这里插入图片描述
构造器重载,参数列表必须不同

4-9 关键字： this的使用

在Java中， this关键字比较难理解，它的作用和其词义很接近。
 它在方法内部使用，即这个方法所属对象的引用；
 它在构造器内部使用，表示该构造器正在初始化的对象

4-10 关键字： package、import的使用

package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。 (若缺省该语句，则指定为无名包)。它的格式为：
package 顶层包名.子包名 ;

MVC 设计模式

在这里插入图片描述

JDK 主要包介绍

1. java.lang----包含一些Java语言的核心类， 如String、 Math、 Integer、 System和
Thread， 提供常用功能
2. java.net----包含执行与网络相关的操作的类和接口。
3. java.io ----包含能提供多种输入/输出功能的类。
4. java.util----包含一些实用工具类， 如定义系统特性、 接口的集合框架类、 使用与日
期日历相关的函数。
5. java.text----包含了一些java格式化相关的类
6. java.sql----包含了java进行JDBC数据库编程的相关类/接口
7. java.awt----包含了构成抽象窗口工具集（abstract window toolkits） 的多个类， 这
些类被用来构建和管理应用程序的图形用户界面(GUI)。 B/S C/S

在这里插入图片描述

面向对象特征之二：继承性inheritance

class Subclass extends SuperClass{ }

方法的重写(override/overwrite)

在子类中可以根据需要对从父类中继承来的方法进行改造，也称
为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。
在这里插入图片描述

5-6 面向对象特征之三：多态性Polymorphism

多态性，是面向对象中最重要的概念，在Java中的体现：
对象的多态性：父类的引用指向子类的对象
可以直接应用在抽象类和接口上
Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明
该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。简称：编译时，看左边；运行时，看右边。
若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)
多态情况下， “看左边” ：看的是父类的引用（父类中不具备子类特有的方法）
“看右边” ：看的是子类的对象（实际运行的是子类重写父类的方法）
子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型(upcasting)。
一个引用类型变量如果声明为父类的类型，但实际引用的是子类
对象，那么该变量就不能再访问子类中添加的属性和方法

Person p = new Student();
Object o = new Person();//Object类型的变量o， 指向Person类型的对象
o = new Student(); //Object类型的变量o， 指向Student类型的对象

方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法
在这里插入图片描述

虚拟方法调用(Virtual Method Invocation)

编译时类型和运行时类型
编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类
的getInfo()方法。 ——动态绑定
重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不
同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了
不同的方法。它们的调用地址在编译期就绑定了。 Java的重载是可以包括父类
和子类的，即子类可以重载父类的同名不同参数的方法。
所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，
这称为“早绑定”或“静态绑定” ；
而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体
方法，这称为“晚绑定”或“动态绑定” 。

instanceof 操作符

对Java对象的强制类型转换称为造型
从子类到父类的类型转换可以自动进行
从父类到子类的类型转换必须通过造型(强制类型转换)实现
无继承关系的引用类型间的转换是非法的
在造型前可以使用instanceof操作符测试一个对象的类型

==和equals的区别

1.== 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址
2 equals的话，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也是==;我们可以看到String等类的equals方法是被重写过的，而且String类在日常开发中
用的比较多，久而久之，形成了equals是比较值的错误观点。
3 具体要看自定义类里有没有重写Object的equals方法来判断。
4 通常情况下，重写equals方法，会比较类中的相应属性是否都相等。

Object类的使用

包装类(Wrapper)的使用

在这里插入图片描述

在static方法

内部只能访问类的static修饰的属性或方法，不能访问类的非static的结构。
因为不需要实例就可以访问static方法，因此static方法内部不能有this。 (也不能有super ? YES!)
 static修饰的方法不能被重写

单例 (Singleton)设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模免去我们自己再思考和摸索。就像是经典的棋谱，不同的棋局，我们用不同的棋谱。 ”套路”
 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构
造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。
在这里插入图片描述

类的成员之四：代码块

在这里插入图片描述

main方法

由于Java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public，又因为Java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static的，该方法接收一个String类型的数组参数，该数组中保存执行Java命令
时传递给所运行的类的参数。
在这里插入图片描述

关键字 final

在这里插入图片描述

抽象类与抽象方法vv

 用abstract关键字来修饰一个类，这个类叫做抽象类。
 用abstract来修饰一个方法，该方法叫做抽象方法。
抽象方法：只有方法的声明，没有方法的实现。以分号结束：
比如： public abstract void talk();
 含有抽象方法的类必须被声明为抽象类。
 抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重
写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍
为抽象类。
 不能用abstract修饰变量、代码块、构造器；
 不能用abstract修饰私有方法、静态方法、 final的方法、 final的类

接口(interface)

class SubClass extends SuperClass implements InterfaceA{ }

在这里插入图片描述

代理模式(Proxy)

代理模式是Java开发中使用较多的一种设计模式。代理设计就是为其
他对象提供一种代理以控制对这个对象的访问。
在这里插入图片描述

异常处理

客户输入数据的格式，读取文件是否存在，网络是否始终保持
通畅，将程序执行中发生的不正常情况称为“异常” 。

Error： Java虚拟机无法解决的严重问题。如： JVM系统内部错误、资源耗尽等严重情况。比如： StackOverflowError和OOM。一般不编写针对性的代码进行处理。
Exception: 其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如：
空指针访问
试图读取不存在的文件
网络连接中断
数组角标越界

7-3 异常处理机制一：try-catch-finally

方式二： throws + 异常类型
在这里插入图片描述

IOException e = new IOException();
throw e;

class MyException extends Exception {
static final long serialVersionUID = 13465653435L;
private int idnumber;
public MyException(String message, int id) {
super(message);
this.idnumber = id;
}
public int getId() {
return idnumber;
}
}

在这里插入图片描述

public class MyExpTest {
	public void regist(int num) throws MyException {
		if (num < 0)
			throw new MyException("人数为负值，不合理", 3);
		else
			System.out.println("登记人数" + num);
	}
	public void manager() {
		try {
			regist(100);
		} catch (MyException e) {
			System.out.print("登记失败，出错种类" + e.getId());
		}
		System.out.print("本次登记操作结束");
	}
	public static void main(String args[]) {
		MyExpTest t = new MyExpTest();
		t.manager();
	}
}

参考链接

【1】https://blog.csdn.net/qq_34477549/article/details/52803821?utm_source=app

和你在一起^_^

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java基础课程概述【笔记】

Java基础课程概述第一部分：编程语言核心结构主要知识点：变量、基本语法、分支、循环、数组、 …第二部分： Java面向对象的核心逻辑主要知识点： OOP、封装、继承、多态、接口、 …第三部分：开发Java SE高级应用程序主要知识点：异常、集合、 I/O、多线程、反射机制、网络编程、 ……第四部分：实训项目项目一：家庭收支记账软件项目二：客户信息管理软件项目三：开发团队人员调度软件附加项目一：银行业务管理软件附件项目二：单机考试管理软件Java基础课程体系第1章 Java语
复制链接

扫一扫