破釜沉舟撞南墙
破釜沉舟撞南墙

尚硅谷Java基础编程

title: Java基础（第一遍）

01 Java语言概述

1.1软件开发介绍

软件

一系列按照特定顺序组织的计算机数据与指令的集合

  • 系统软件-Windows Linux Mac Android
  • 应用软件

流程图

TRUE
FALSE
递归函数
执行语句
条件
执行语句
退出

人机交互方式

图形化界面（Graphical User Interface GUI)

命令行方式（Command Line Interface CLI）

命令行指令

切换盘符 d:

列出子目录 dir

退出当前目录 cd..

打开文档 cd

创建目录（文件夹）md

一次性退出到根目录 cd\

创建文件 echo name : tom >1.doc name : tom是需要写入的东西，可以不写\

删除文件目录rd（如果里面有内容删除不了，需要进入然后删除文件）

删除文件 del del *.txt(删除同类文件)，如果直接del删除文件内的内容

退出 exit

常用快捷键

  • ← →：移动光标
  • ↑ ↓：调阅历史操作命令
  • Delete和Backspace：删除字符

1.2计算机语言介绍

什么是计算机语言

人与计算机交流的方式

语言 = 语法 + 逻辑

C，C++，Java，PHP，Kotlin，Python，Scala .et al

登录界面
HTTP

语言的分代

第一代 机器语言

第二代 汇编语言 使用助记符表示一条机器指令

第三代 高级语言

  1. 面向过程 C
  2. C ++ Cpp
  3. 面向对象 Java
高级语言
汇编语言

Android/why is Java?

市场需求

https://www.tiobe.com/tiobe-index/

C 运行效率高

  • 操作系统
  • 嵌入式设备（汽车，洗衣机）
  • 动画制图

Python 开发效率快，运行速度更低

  • 爬虫
  • 数据分析
  • AI
  • 后台
  • 自动化运维

PHP

  • 后台

C# 不开源

Java 社区最活跃

JavaScript 前端

SQL

Swift 与 OC Apple

Go Google （头条替换成Go）

1.3 Java语言概述

1995 SUN（Stanford University Network）

简史

1991 Oak（橡树）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M8pjwgsU-1596345581891)(images/image-20200721114138877.png)]

爪哇岛 生产咖啡

2004 JDK 1.5 突破版本 更名JDK 5.0

2009 74亿美元 Oracle收购

2014 JDK8.0 使用量最大

LTS 8 11 长期维护版本

每隔三年发布一个LTS

Java技术体系平台

Java SE (Java Standard Edition)标准版
支持面向桌面级应用（如Windows下的应用程序）的Java平台，提供了完整的Java核心API，此版本以前称为J2SE
**Java EE(Java Enterprise Edition)企业版 **
是为开发企业环境下的应用程序提供的一套解决方案。该技术体系中包含的技术如:Servlet 、Jsp等，主要针对于Web应用程序开发。版本以前称为J2EE
Java ME(Java Micro Edition)小型版
支持Java程序运行在移动终端（手机、PDA）上的平台，对Java API有所精简，并加入了针对移动终端的支持，此版本以前称为J2ME
Java Card
支持一些Java小程序（Applets）运行在小内存设备（如智能卡）上的平台

Java语言特点

面向对象

健壮性

  • 去除了指针
  • 增加了内存管理

跨平台（write once run anywhere)

  • JVM Java虚拟机 实现Java语言跨平台
  • 不同系统的JVM不一样（Win、Linux、Mac）

1.4 运行机制及其运行过程

JVM是一个虚拟的计算机

Java舍弃了C的指针

增加了垃圾回收机制//自动的内存管理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VnglIqCJ-1596345581893)(images/image-20200721143247317.png)]

1.5 Java语言的环境的搭建

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JmCxSigG-1596345581894)(images/image-20200721173749991.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-A0Cm1K7O-1596345581897)(images/image-20200721180531394.png)]

配置环境变量

需在任何文件路径下能够执行javac与java文件

path：windows在执行命令时要搜寻的路径

  1. 我的电脑–属性–高级系统设置–环境变量
  2. 编辑 path 环境变量，在变量值开始处加上java工具所在目录，后面用 “ ; ”和其他值分隔开即可。
  3. 打开DOS命令行，任意目录下敲入javac。如果出现javac 的参数信息，配置成功。

设置JAVA_HOME

新建环境变量JAVA_HOME

JAVA_HOME = C:\Program Files\Java\jdk1.8.0_131

新增Path环境变量，将

D:\developer_tools\Java\jdk1.8.0_131\bin

替换为

%JAVA_HOME%\bin;

测试

java -version

为什么要使用JAVA_HOME?

为了以后默认寻找JAVA_HOME的方便

注意：要把JAVA_HOME放在前面

1.6 开发体验-Hello World

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hYGsbqCT-1596345581898)(images/image-20200721142800174.png)]

ln为line的意思，属于单行打印

想当于打印与换行符同时进行

class HelloChina{
    public static void main(String[] args){
        System.out.println("Hello world!");
    }
    //ln是相当于print+line，属于单行打印的意思
}
class HelloChina{
    public static void main(String[] args){
        System.out.print("Hello World!");
        //单行注释，此行没有换行符
        System.out.println();
        //相当于换行符
        System.out.println("Hello WOrld!");
    }
}

写完之后注意保存

1.7 Java注释信息

文档注释的注意事项

  • 文档注释需要用于放置于类的前面用于标记声明类，放置于类后面@不展现
  • 一个java源文件声明多个类编译之后会生成多个字节码文件（对应原文件中不同的类）
  • 要想使用java.exe命令解释运行成功，必须保证对应的类中声明有main()方法。
    main()的格式是固定的！
  • main()作为程序的入口！
  • 如果源文件中的一个类想用public修饰，则要求此类的类名必须与源文件的文件名相同。
/*
一、测试Java中的三种注释

1. 单行注释 //
2. 多行注释

3. 文档注释（java特有）

二、单行和多行注释的作用：
① 对编写的代码进行解释说明
② 进行代码的调试

三、说明
1. 单行注释和多行注释，被注释掉的信息，是不参与编译的。
2. 多行注释是不能嵌套使用的。

四、文档注释

特点：
注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。
*/

    
/**
文档注释：
放置于类的前面，用于声明类的注释
这是我的第一个Java程序！
@author shkstart
@version 1.0
*/

public class CommentTest{
	/**
	如下的方法是main()方法，作为程序的入口
	*/
    
	/*
	main()的格式是固定的！
	*/
	public static void main(String[] args) {
		//单行注释
		//System.out.println("Hello World!")
	}
}

对编写的代码进行解释说明

注释相当于药的说明书

多行注释不能嵌套使用

文档注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VoH0Xa8K-1596345581901)(images/image-20200721154516861.png)]

mydoc是自己起的名字,生成文件目录

打开index首页

1.9 Java API文档

API （Application Programming Interface,应用程序编程接口）是 Java 提供的基本编程接口。

Java语言提供了大量的基础类，因此 Oracle 也为这些基础类提供了相应的API文档，用于告诉开发者如何使用这些类，以及这些类里包含的方法。类似于学习汉字使用的《新华字典》

注意搜索查看

相当于辞典

1.10 良好的编程风格

使用文档注释来注释整个类或整个方法

使用注释方法注释某一个步骤

使用TAB操作进行缩进

运算符两端加空格

块的风格可以做选择

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-foQMwXKn-1596345581903)(images/image-20200721160253466.png)]

总结

1.编写-编译-运行三个步骤：
	① 编写：将编写的java程序保存在.java结尾的源文件中。比如：Hello.java
	② 编译：使用javac.exe指令对编写的java源文件进行编译。比如：javac Hello.java
        编译之后，生成.class结尾的字节码文件。
	③ 运行：使用java.exe指令对生成的字节码文件，进行解释运行。比如：java HelloShangHai
2. 在一个java源文件中，是可以声明多个类的。那么编译之后，就会生成对应的类名的多个字节码文件。
3. 要想使用java.exe命令解释运行成功，必须保证对应的类中声明有main()方法。
   main()的格式是固定的！
4. main()作为程序的入口！
5. 如果源文件中的一个类想用public修饰，则要求此类的类名必须与源文件的文件名相同。
   > 结论：一个源文件中，最多只能有一个类声明为public的
6. 输出语句：
   类型一：System.out.println()  在执行完输出语句之后，会换行
   类型二：System.out.print()   在执行完输出语句之后，不会换行
7. 所有的执行语句，必须以";"结尾
*/
class HelloShangHai {
	public static void main(String[] args) {//args: arguments,参数
		System.out.println("Hello World!");
		System.out.println("Hello World!");//"Hello World!" : 字符串
		System.out.println("Hello World!");
	}
}

class HelloBeiJing{
}

class HelloShenZhen{
	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
}

class HelloGuangZhou{
}

public class Hello{//public修饰与否，影响的是Hello类被调用时的权限的大小

}

02 Java基本语法

2.1 关键字和保留字

关键字(Keyword)

  • 定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
  • 特点：关键字中所有字母都为小写

保留字(reserved word)

  • 现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字
  • goto 、const
关键字 名称 介绍
byte 单字节类型 1个字节（8位）[-128,127]
short 短整型 2个字节（16位）[-215,215-1]
int 整型 4个字节（32位）[-231,231-1]
long 长整型 8个字节（64位）[-263,263-1]
char 单字符类型 2个字节（16位）
float 单精度浮点型 4个字节 科学计数法保留小数点6-7位+F或者f
double 双精度浮点型 8个字节 科学计数法表示小数点15-16位
boolean 布尔类型 true and false

2.2 标识符

Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符

技巧：凡是自己可以起名字的地方都叫标识符。

2.2.1 定义合法标识符规则：

  • 由26个英文字母大小写，0-9，_ 或 $ 组成

  • 数字不可以开头

  • 不可以使用关键字和保留字，但能包含关键字和保留字

class public1//public不行
  • Java中严格区分大小写，长度无限制，在windows中不区分大小写，会发生覆盖
  • 标识符不能包含空格

2.2.2 命名的规范

包名：多单词组成时所有字母都小写：xxxyyyzzz

类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz 大驼峰

变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz 小驼峰

常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

如果用户不遵守规范，编译与运行都不受影响

2.3 变量

2.3.1 变量的概念

  • 内存中的一个存储区域
  • 该区域的数据可以在同一类型范围内不断变化
  • 变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值

2.3.2变量的作用

  • 用于在内存中保存数据
/*
测试变量的定义
变量的声明与赋值
格式： 数据类型 变量名 = 变量值；
*/
class VaribleTest{
    public static void main(String[] args){
        int number;//变量的声明
        number = 1;//变量的赋值
        //变量的声明与赋值
        int count = 2;
        System.out.println(number + 1);
    }
}

2.3.3 变量注意点

  1. java是强类型的语言，声明的每个变量，一定要指明其变量类型
  2. 变量一定需要在赋值之后才可以使用(java没有初始化)
  3. 变量需要先声明在赋值
  4. 变量都有其作用域，超出作用域范围后，就失效 { }
  5. 在同一个作用域范围内，不能同时存在相同的变量名
/**文档注释示例

*/

2.3.4基本数据类型

<1> 数据类型的分类

按数据类型分

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FAlKe5Pf-1596345581905)(images/image-20200722103300390.png)]

整型：byte\short\int\long

浮点型：float\double

字符型：char

布尔型：boolean

<2> Java整型

  • Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。
  • 超过范围编译不通过
  • java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’，一般默认加L
  • java程序中变量通常声明为int型除非不足以表示较大的数，才使用long，一般使用int
关键字 名称 介绍
byte 单字节类型 1个字节（8位）[-128,127]
short 短整型 2个字节（16位）[-215,215-1]
int 整型 4个字节（32位）[-231,231-1]
long 长整型 8个字节（64位）[-263,263-1]
char 单字符类型 2个字节（16位）
float 单精度浮点型 4个字节 科学计数法保留小数点6-7位+F或者f
double 双精度浮点型 8个字节 科学计数法表示小数点15-16位
boolean 布尔类型 true and false

<3> Java浮点类型

与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。

浮点型常量有两种表示形式：

  • 十进制数形式：如：5.12 512.0f .512 (必须有小数点）
  • 科学计数法形式:如：5.12e2 512E2 100E-2

float：单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。

定义float类型的变量在赋值时，需要’F’或者’f’，否则编译错误

float存储范围比long还要大，但是精度降低

double：双精度，精度是float的两倍。通常采用此类型

Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’

类 型 占用存储空间 表数范围
单精度float 4字节 -3.403E38 ~ 3.403E38
双精度double 8字节 -1.798E308 ~ 1.798E308

<4> 字符类型char

char 型数据用来表示通常意义上“字符” (2字节)

Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符

字符型变量的三种表现形式：

  • 字符常量是用单引号==‘ ’==括起来的单个字符。
char c1 = 'a';
char c2 = '1';
char c3 = 'zhong';
char c4 = 'd';
char c5 = 'ab';//编译不通过
char c6 = '';//编译不通过
  • 转义字符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W0bMfpEw-1596345581907)(images/image-20200722111203167.png)]

char c7 = '\n';//换行符
char c8 = '\t';//制表符，缩进

  • 直接使用 Unicode 值来表示字符型常量：\uXXXX。其中，XXXX代表一个十六进制整数。如：

    \u000a = \n;
//char类型是可以进行运算的。因为它都对应有Unicode码。

u是Unicode 通过映射表进行对照

<5> Unicode 编码

Unicode：一种编码，将世界上所有的符号都纳入其中。

每一个符号都给予一个独一无二的编码，使用 Unicode 没有乱码的问题。

Unicode 的缺点：

  • Unicode 只规定了符号的二进制代码，却没有规定这个二进制代码应该如何存储：无法区别 Unicode 和 ASCII：计算机无法区分三个字节表示一个符号还是分别表示三个符号。
  • 每个字符都用三个或者四个字节存储，浪费了存储空间。

Unicode向下兼容了ASCII码

<6> UTF-8

UTF-8 是在互联网上使用最广的一种 Unicode 的实现方式。

UTF-8 是一种变长的编码方式。它可以使用 1-6 个字节表示一个符号，根据不同的符号而变化字节长度。

UTF-8的编码规则：

  • 对于单字节的UTF-8编码，该字节的最高位为0，其余7位用来对字符进行编码（等同于ASCII码）。
  • 对于多字节的UTF-8编码，如果编码包含 n 个字节，那么第一个字节的前 n 位为1，第一个字节的第 n+1 位为0，该字节的剩余各位用来对字符进行编码。在第一个字节之后的所有的字节，都是最高两位为"10"，其余6位用来对字符进行编码。

<7> ASCII码

在计算机内部，所有数据都使用二进制表示

一共规定了128个字符

//使用ASCII码对应数值
char c9 = 97;//a
char c10 = 65;//A

<8> 布尔类型：boolean

只有两个值

//常常在循环结构，条件判断结构中使用
boolean bo1 = true;
boolean bo2 = false;
if(bo1){
    System.out.println("true");
}
else{
    System.out.println("false");
}

2.4 运算规则

public class StringTest{
    public static void main(String[] args){
        int no = 10;
        String str = "abcdef";
        String str1 = str + "xyz" + no;//abcdefxyz10
        str1 = str1 + "123";//abcdefxyz10123
        char c = '国';
        
        double pi = 3.1416;
        str1 = str1 + pi;//abcdefxyz101233.1416
        boolean b = false;
        str1 = str1 + b;
        str1 = str1 + c;
        
        System.out.println("str1 = " + str1); 
    }
}

2.4.1 数据自动类型转换默认int double

  1. 当存储范围小的数据(变量/表达式/常量)，赋值给存储范围大的变量时，自动升级为该存储范围大的类型

    double d = 12; 
//容量大小指的不是数据类型占用空间的大小，指的的存储量的大小 long 与 float
    char
    int
    byte
    short
    long
    float
    double

  2. 当byte与byte,short与short，char与char，byte,short,char之间一起运算了，都会自动升级为int

    byte b1 = 1; 
byte b2 = 2; 
int sum = b1 + b2;//sum为int

  3. 当多种基本数据类型的数据一起混合运算，会自动升级为它们中大的类型

    char c = 'a';//97 
int b = 12; 
double d = 2.8; 
double sum = c + b + d;

  4. 当基本数据类型的数据 与 String类型进行“+”拼接时，结果自动转为String类型。

    <1>String: 字符串，使用一对“”表示

    <2>String s1 = " ";内部可以声明0个，1个或者多个字符

    <3>String只能和8种基本数据类型的变量做连接运算

    <4>运算的结果只能是String类型

    String str = 12 + ""; 
int n1 = 10;
String s2 = "abc";
String s3 = n1+s2;
boolean a = true;
String s4 = s2 + b1;//结果也是拼接上
System.out.println(s4);//abctrue

System.out.println(s2+n1+b1);//字符串的拼接
System.out.rintln(n1+b1+s2);//从左到右计算，而int无法与boolean做运算，发生编译失败
System.out.println(n1 + (b1 + s2));

  5. boolean类型不和其他基本数据类型发生转换

2.4.2 强制类型转换

当存储范围大的数据（变量、表达式、常量）赋值给存储范围小的变量时，都是需要强制类型转换

强制类型转换，需要使用强转符==（）==

注意：可能会溢出，或者损失精度

  • 截断
  • 越界
//例如： 
double d = 1.2; 
int num = (int)d;//强制类型转换

float f1 = 12.9F;//第一种精度损失
int num1 = (int)f1;
System.out.println(num1);//截断输出，输出结果是12

int num2 = 128;//第二种精度损失
byte l2 = (byte)num2;
System.out.println(l2);//输出结果-128
double
float

当某个数据（变量、表达式、常量）想要让它按照某个大的类型进行计算时，也 可以使用强制类型转换

//例如： 
int a = 1; 
int b = 2; 
double shang = (double)a/b;

boolean和String都是无法通过强制类型转换为基本数据类型的值。

练习

练习1

System.out.println('*'+'\t'+'*');//93
System.out.println('*'+"\t"+'*');//正常,制表符
System.out.println('*'+'\t'+"*");//51*
System.out.println("*"+'\t'+'*');//正常

练习2

int num = 10;
char c = 'a';
String s = "hello";
System.out.println(num + c + s);//107hello
System.out.println(s + c + num);//helloa10
System.out.println(num + ( c + s));//10ahello

练习3

String str1 = 4;					//判断对错：对
String str2 = 3.5f + “”;  			//判断str2对错：对
System.out.println(str2);		    //输出：3.5
System.out.println(3 + 4 + "Hello!");   //输出：7hello!
System.out.println("Hello!"+ 3 + 4);   //输出：hello!34
System.out.println('a' + 1 +"Hello!"); //输出：98hello!
System.out.println("Hello" + 'a' + 1);  //输出：helloa1

2.4.3 关于常量

int num1 = 10;
num1 = 20;
//对于整型常量而言，默认是int类型
int num2 = num1 + 30;//结果是int类型
//byte num2 = num1 + 30;运行不过
//对于浮点型常量而言，默认是double类型
double b1 = b1 + 12.3;

2.4.4 进制

<1> 进制的表示

  • 二进制(binary)：以0b或0B开头

  • 十进制(decimal)：

  • 八进制(octal)：以数字0开头表示。

  • 十六进制(hex)：以0x或0X开头表示。此处的A-F不区分大小写。

    如：0x21AF +1= 0X21B0

<2> 原码补码反码

过程 原码 反码（除符号位取反） 补码（+1）
1 0000 0001 0000 0001 0000 0001
-1 1000 0001 1111 1110 1111 1111
0000 0000

<3> 十进制转二进制

无符号数十进制数转二进制算法

十进制数重复除以2，每次的余数记录下当做二进制数位的值，直到商为0为止

举例：十进制数57转为二进制数

除法 商 余数
57/2 28 1
28/2 14 0
14/2 7 0
7/2 3 1
3/2 1 1
1/2 0 1

把余数列数字反向排列就得到了二进制数111001，由于intel存储的二进制数位数总是8或者8 的倍数，因此前面的空位补0

57的二进制数是00111001

<4> 二进制转十进制

位权表示法

1 0 1 1 0 1 0 1
7 6 5 4 3 2 1 0
1*27 0*26 1*25 1*24 0*23 1*22 0*21 1*20

算法：位权表示法把n位无符号数二进制整数转换为十进制数（不考虑正负数）
d e c = ( D n − 1 ∗ 2 n − 1 ) + ( D n − 2 ∗ 2 n − 2 ) + . . . + ( D 1 ∗ 2 1 + ( D 0 ∗ 2 0 ) ) dec = (D_{n-1}*2^{n-1})+(D_{n-2}*2^{n-2})+...+(D_{1}*2^{1}+(D_{0}*2^{0})) dec=(Dn−1​∗2n−1)+(Dn−2​∗2n−2)+...+(D1​∗21+(D0​∗20))

<5> 十进制转十六进制

无符号数十进制数转十六进制数算法：

十进制数重复除以16，每次的余数记录下来作为当前十六进制数位的值

直到商为0为止

举例：十进制数422转为十六进制数

除法 商 余数
422/16 26 6
26/16 1 A
1/16 0 1

把余数列数字反向排列就得到了十六进制数的1A6H，由于Intel存储的二进制数位数总是8或者8的倍数，因此前面空位补0, 422的十六进制为01A6H

<6> 十六进制转十进制

1 6 A 7 9 4
0001 0110 1010 0111 1001 0100
1*165 6*164 10*163 7*162 9*161 4*160

算法：位权表示法把n位无符号数十六进制整数转换为十进制数（不考虑正负数）
d e c = ( D n − 1 ∗ 1 6 n − 1 ) + ( D n − 2 ∗ 1 6 n − 2 ) + . . . + ( D 1 ∗ 1 6 1 + ( D 0 ∗ 1 6 0 ) ) dec = (D_{n-1}*16^{n-1})+(D_{n-2}*16^{n-2})+...+(D_{1}*16^{1}+(D_{0}*16^{0})) dec=(Dn−1​∗16n−1)+(Dn−2​∗16n−2)+...+(D1​∗161+(D0​∗160))

<7>二进制转八进制

  • 三个一位

<8>二进制转16进制

  • 四个一位

2.5 运算符

2.5.1 算术运算符

赋值运算符

比较运算符

逻辑运算符

运算符 运算 范例 结果
+ 正号 + 3 3
- 负号 b = 4; -b -4
+ 加 5 + 5 10
- 减 6 - 4 2
***** 乘 3 * 4 12
/ 除 5 / 5 1
% 取模(取余) 7 % 5 2
++ 自增（前）：先运算后取值 a = 2; b = ++a; a = 3;b = 3
++ 自增（后）：先取值后运算 a = 2; b = a++; a = 3;b = 2
- - 自减（前）：先运算后取值 a = 2; b = --a; a = 1;b = 1
- - 自减（后）：先取值后运算 a = 2; b = a–; a = 1;b = 2
+ 字符串连接 “He” + ”llo” “Hello”

除法说明

//关于除法的一些说明
int m1 = 12;
int m2 = 5;//2
int m3 = m1/m2;//10
double m4 = (double) m1/m2;//2.4

整型获得数是整型

使用强制类型转换

模数符号说明

//关于模数的符号的了解
int m1 = 12%5;//
int m1 = -12%5;//-2
int m3 = 12%-5;
int m4 = -12%-5;//-2

符号与被模数相同

a++与++a说明

  • （前）++ ：先自增1，在赋值

  • （后）++：先赋值，在自增1

  • –与++相同

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U3uOBzUQ-1596345581908)(images/image-20200724111548518.png)]

2.5.2 赋值运算符

class SetValues{
    public static void main(String[] args){
        //赋值运算符：=
        int a = 10;
        int b = 10;
        int a1,a2;
        a1 = a2 = 10;//连续赋值
        System.out.println("a="+a);
        System.out.println("b="+b);
        System.out.println("a1="+a1);
        System.out.println("a2="+a2);
        
        int a3 = 10, a4 = 10;
        System.out.println("a3="+a3);
        System.out.println("a4="+a4);
        
        int m = 10;
        m += 5;//m = m + 5
        System.out.println("m = " + m);
        //+= -= *= %=
    }
short m;
m += 5;
m = m + 5;//不相同
m =(short)(m=5);

两者有点类似

总结：开发中如果需要变量自增2，建议使用：+=2，而不是使用+2

int i = 10;
i += 5.0;//这个相同于
//i = (int)5.0;
System.out.println("i=" + i);

i+=与普通的运算式明显不同，可以理解为+=的过程中，会以 i 的类型对+=之后的数发生强制类型转换。

练习

<1> 示例1

int m1 = 2;
int n1 = 3;
n1 *= ++m1;
System.out.println("m1="+m1);//3
System.out.println("n1="+n1);//9

<2> 示例2

int n3 = 10;
n3 += (n3++) + (++n3);//n3 = n3 + (n3++) + (++n3)
System.out.println(n3);//32

在进行++或者–运算式，（a++) 这个整体已经自增1，但是赋值的情况下是先赋值，但是在进行四则运算的时候就不一样了。

<3> 示例3

多项运算式的变换

从左往右依次计算

int k = 0，j = 0;
j += k* = j += (k = 1)/(j = 1);
上述正则表达式可以进行简写
j = j + (k = k * (j = j + (k=1)/(j=1)))
System.out.println(j);//0
int k = 0;
int j = 0;
j += ++k + (++k +j);
上述可以改写成
    j = j + (++k + (++k +j))
    j = 0 + (1 + (2+0))
System.out.println(j);//3

2.5.3 比较运算符

运算符 运算 范例 结果
== 相等于 4==3 false
!= 不等于 4!=3 true
< 小于 4<3 false
> 大于 4>3 true
<= 小于等于 4<=3 false
>= 大于等于 4>=3 true
instanceof 检查是否是类的对象 “Hello” instanceof String true

说明

运算的结果是布尔类型

区分赋值符号 == =

System.out.println(a == b);//false
System.out.println(a = b);//b

2.5.4 逻辑运算符

a b a&b 且true a&&b 且true a|b 或 a||b 或 !a a^b 不同为true
true true true true true true false false
true false false false true true false true
false true false false true true true true
false false false false false false true false

逻辑运算符使用

&逻辑与

&&短路与

说明

操作的是boolean类型变量

运算的结果也是boolean类型

区分&与&&

boolean b1 = false;
boolean b2 = true;
int m1 = 10;
if(b1 & (m1++>0)){
    System.out.println("执行if结构");
}else{
    System.out.println("执行else结构");
}
System.out.println("m1="+m1);

int m2 = 10;
if(b1 && (m2++>0)){
    System.out.println("执行if结构");
}else{
    System.out.println("执行else结构");
}
System.out.println("m2="+m2);

int m3 = 10;
if(b2 | (m3++>0)){
    System.out.println("执行if结构");
}else{
    System.out.println("执行else结构");
}
System.out.println("m1="+m1);

int m4 = 10;
if(b2 || (m4++>0)){
    System.out.println("执行if结构");
}else{
    System.out.println("执行else结构");
}
System.out.println("m2="+m2);

& 左边是false，依然执行右边

&&左边是false，不执行右边操作（短路）

|左边是true，依然执行右边

||左边是true，不执行右边操作（短路）

结论

开发中，建议大家使用短路情况

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OJW0FYO7-1596345581910)(images/image-20200724111722689.png)]

2.5.5 位运算符

位运算符
运算符 运算 范例
<< 左移 3 << 2 = 12 --> 322=12
>> 右移 3 >> 1 = 1 --> 3/2=1
>>> 无符号右移 3 >>> 1 = 1 --> 3/2=1
& 与运算 6 & 3 = 2
| 或运算 6 | 3 = 7
^ 异或运算 6 ^ 3 = 5
~ 取反运算 ~6 = -7

说明：

针对于整数，不管整数还是负数：左移一位乘以2，当最高位左移到边缘时，符号位发生了变化。

针对于整数，不管是正数还是负数，在一定范围内，只要向右移动了一位。就相当于/2

-7>>1;//-4

无符号位移>>>补0，用来取最小四位，如1111 0000 >>>4 = 0000 1111

增加1.5倍的算法，使用位运算

10+15;
10+10>>1;//除以2的倍数

练习

如何手动实现整型数值60的二进制到十六进制的转换

//[answer]
String str1 = Integer.toBinaryString(60);
String str2 = Integer.toHexString(60);
int i1 = 60;
int i2 = i1&15;
//通过二进制数0000 1111，获取60二进制数的低四位
String j = (i2 > 9)?(char)(i2-10+'A'):i2 + "";

int temp = i1>>>4;//无符号进位4
//通过无符号数位移获得i1的高四位二进制数
i2 = temp & 15;
String k = (i2 > 9)?(char)(i2-10+""):i2+"";
System.out.print(k+""+j);

交换两者的值

int m = 4;
int n = 2;
//方式1
int temp = m;
	   m = n;
	   n = temp;//注意斜的是一样的
//方式2，字符串类型不通用
m = m + n;
n = m - n;
m = m - n;
//方式3，使用位运算
m = m^n;//拿出两者的不同
n = m^n;//把其中一个不同改变
m = m^n;

在使用位运算中

m^n = a;//m^n^n = m
a^n = m;//n^m^m = n
int m = 4 0000 0100
int n = 2 0000 0010
进行异或位运算 1111 1001
在与2进行异或运算 0000 0100

可以预见，在与一个数进行两次异或运算后，会变成自己的本身

2.5.6 三元运算符

说明：

  • 条件表达式是 boolean 类型
  • 如果条件表达式是true，则返回表达式1
  • 如果条件表示式是false，则返回表达式2

要求表达式1和表达式2要一致

使用三元运算符的地方都可以改写为if-else

关于三元运算符比较两者相同条件下的注意事项：

int m = 20;
int n = 20;
String max = (m > n)?"m大":"n大";
System.out.println(max)//n

在相同的条件下 n大

可以嵌套

//求a1，a2,a3的最大值
int max1 = (a1 > a2)?a1:a2;
int max2 = (max1 > a3)?max1:a3;
int max1 = (((a1 > a2)?a1:a2;) > a3)?((a1 > a2)?a1:a2;):a3;

在能使用三元运算符的情况下建议使用三元运算符

因为三元运算符执行效率稍微高一点

2.5.7 运算符的优先级

（）

2.6 程序控制流程

2.6.0 如何获取键入的不同类型的数据

使用Scanner来实现

操作步骤

  • 导入包
  • 实例化Scanner
  • 根据需要获取变量的类型，调用相关的方法即可
import java.util.Scanner;
class ScannerTest{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);//实例化

        System.out.println("请输入姓名");
        String name = scan.next();//获取一个字符串
        System.out.println("name=" + name);
        
        System.out.println("请输入年龄");
        int age = scan.nextInt();//获取一个Int类型
        System.out.println("name=" + age);
        
        System.out.println("请输入体重");
        Double weight = scan.nextDouble();//获取一个浮点类型
        System.out.println("wieght=" + weight);
        
        System.out.println("婚否(true/false)");
        boolean isMarried = scan.nextBoolean();//获取一个布尔类型
        System.out.println("isMarried？" + isMarried);

		System.out.println("请输入您的性别");
        String gender = scan.next();
		char chargender = gender.charAt(0);//获得索引为0的字符
        System.out.println("gender：" + chargender);
    }
}

流程控制语句是用来控制程序中各个语句执行顺序的语句，可以把语句组合成 能完成一定功能的小逻辑模块

其流程控制方式采用结构化程序设计中规定的三种基本流程结构

  • 顺序结构

  • 分支结构

    if...else;
switch-case;

  • 循环结构

    while;
do...while;
for;

2.6.0 如何使用equals判断字符串相等

if(height >= 180 && wealth >= 1 && "是".equals(isHandsome));
import java.util.Scanner;
class Dome10Equals{
	public static void main(String[] args){
		Scanner input = new Scanner(System.in);
		String iftest = input.next();
		boolean a = "是".equals(iftest);//如果字符串相等，则会返回true
		System.out.println(a);
	}
}

2.6.0 如何使用==Math.random()==获得随机数

如何获取一个随机数？

  1. 通过调用Math.random()，可以获取一个[0,1)范围的内的double型的随机数

  2. 获取[10,99]范围内的随机数？
    int number = (int)(Math.random() * 90 + 10);

  3. 获取[100,999]范围内的随机数？
    int number = (int)(Math.random() * (999-100+1) + 100);

总结：获取[a,b]范围的随机数的公式
( i n t ) ( M a t h . r a n d o m ( ) ∗ ( b − a + 1 ) + a ) ; (int)(Math.random() * (b - a + 1) + a); (int)(Math.random()∗(b−a+1)+a);

int a = Math.random();
int b = (int)(Math.random()*90 + 10);//[10,100)
//获得三位随机数
int c = (int)(Math.random()*(1000-100)+100);//[100,1000)

int b = (int)(Math.random()*91 + 10);//[10,100]
//获得三位随机数
int c = (int)(Math.random()*(1001-100)+100);//[100,1000]

2.6.1 顺序结构

（）

2.6.2 分支语句

条件表达式必须是布尔表达式（关系表达式或者逻辑表达式）、布尔变量

语句块只有一条执行语句，一对{}可以省掉，但是建议保留

if-else语句结构根据需要可以嵌套使用

当if-else结构是“多选一”时，最后的else是可选的。根据需要可以省掉

只执行一块代码，

执行完毕后，跳出当前if-else语句

if-else不能80

因为80与score相比已经是布尔型，布尔型不能跟90运算，所以报错

示例

class Iftest{
    public static void main(String[] args){
        int heatBeats = 80;
        if(heartBeats<60||heartBeats>100){
            System.out.println("you need continue test");
        }
        System.out.println("体检结束");
    }  
}

else根据需要来选

例题1

/**
	岳小鹏参加Java考试，他和父亲岳不群达成承诺：
	如果：
		成绩为100分时，奖励一辆BMW；
		成绩为(80，99]时，奖励一台iphone xs max；
		当成绩为[60,80]时，奖励一个 iPad；
        其它时，什么奖励也没有。
	请从键盘输入岳小鹏的期末成绩，并加以判断
*/
import java.util.Scanner;//导包

class Demo5
{
   public static void main(String[] args)
   {
       Scanner grades = new Scanner(System.in);
       System.out.print("请输入您测试得到的分数：");//给用户提示
       int grade = grades.nextInt();
       if (grade == 100){
           System.out.println("Congratlations ! You get BMW*1");
       }else if(grade>80){
           System.out.println("Congratlations ! You can get iphone xs max*1");
       }else if(grade>60){
           System.out.println("Don't worry! You can get iPad*1");
       }else{
           System.out.println("What a pity! You can't get anything");
       }
   }
}

说明

如果多个表达式彼此之间是“互斥”关系，（即：没有交集），则那个条件在上，那个在下无所谓

如果多个条件表达式彼此之间是“包含”关系，则需要将条件表达式范围小的声明在条件表达式范围大的上面

例题2 三个数字排序并输出

/**
编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，对它们进行排序(使用 if-else if-else),并且从小到大输出。
*/
import java.until.Scanner;

class Demo
{
  public static void main(String[] args)
  {
      Scanner num = new Scanner(System.in);
      System.out.print("请输入num1");
      int num1 = num.nextInt();
      System.out.print("请输入num2");
      int num2 = num.nextInt();
      System.out.print("请输入num3");
      int num2 = num.nextInt();
      
      if(num1>num2)
      {
          int temp = num1;
          num1 = num2;
          num2 = temp;
      }
      if(num2>num3)
      {
          int temp = num2;
          num2 = num3;
          num3 = temp;
      }
      if(num1>num2)
      {
          int temp = num1;
          num1 = num2;
          num2 = temp;
      }
  }
}

2.6.3 分支语句2 Switch-case结构

switch(表达式)
{
    case 常量1:
        语句1;
        break;
    case 常量N:
        语句N;
        break;
    default:
        语句;
        break;
}

break跳出当前switch-case结构

否则不会跳出代码块，依次执行

执行过程：根据switch中表达式的值，依次匹配各个case中的常量

当与某个常量匹配上时，就进入case中

调用case语句，执行完之后，依然会考虑继续执行器后的case中的结构，直接预见break

示例

public class Switchtest
{
    public static void main(String args[])
    {
        int i = 1;
        switch(i)
        {
            case 0:
                System.out.println("zreo");
                break;
            case 1:
                System.out.println("one");
            default:
                System.out.println("default");
                break;//可写可不写
        }
    }
}

局限性：

switch中的表达式的值可以是如下类型。类型存在限制，

比如boolean类型与double类型不能使用

byte;
short;
char;
int;
枚举类(jak5.0新增);
String(jdk7.0新增);

表示范围不方便，但是可以通过除法进行判断，如示例1所示

case语句还可以进行合并，如示例1所示

//示例1
//对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”
switch(score/10){
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
        System.out.println("不及格");
        break;
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
        System.out.println("及格");
        break;
}
//更加注意switch结构灵活运用
switch(score/10){
    case 1:
        System.out.println("及格");
    case 0:
        System.out.println("不及格")
}

匹配的case通常不能太多

关于default默认值（相当于if-else里面的else）

可选的，位置也是灵活的

但是即使在中间插入default也是最后判断default，一般不这么书写

建议在什么情况下使用switch

switch-case可以完全转换为if-else，if-else不一定能够改写成switch-case。比如boolean类型Switch-case结构不能使用

如果判断的具体数值不多。而且符合byte、short、char、int、String、枚举等几种类型。

虽然两个语句都可以使用，建议使用switch语句。因为效率稍高。

其他情况：对区间判断，对结果为 boolean 类型判断，使用if，if的适用范围更广，也就是说，使用switch-case的，都可以改写成if-else。反之不成立

结论：如果多个语句的相同可以自动往下走，考虑合并

例题：日期与天数//Switch-case的不用break的条件

编写程序：从键盘上输入2020年的“month”和“day”，要求通过程序输出输入的日期为2020年的第几天。

import java.util.Scanner;

class Demo11Month 
{
	public static void main(String[] args) 
	{
		Scanner scan = new Scanner(System.in);
		System.out.println("请您输入月份");
		int month = scan.nextInt();//输入几月
		System.out.println("请您输入日子");
		int day = scan.nextInt();//输入几号

		int sumDays = 0;//记录总天数
		switch(month){
			case 12:
				sumDays += 30;
			case 11:
				sumDays += 31;
			case 10:
				sumDays += 30;
			case 9:
				sumDays += 31;
			case 8:
				sumDays += 31;
			case 7:
				sumDays += 30;
			case 6:
				sumDays += 31;
			case 5:
				sumDays += 30;
			case 4:
				sumDays += 31;
			case 3:
				sumDays += 29;
			case 2:
				sumDays += 31;
			case 1:
				sumDays += day;
		}
		System.out.println(month + "月份" + day + "日为本年的第"+sumDays+"天");
		System.out.println("Hello World!");
		}
}

例题：判断case里面嵌套if-else判断是否为闰年

从键盘分别输入年、月、日，判断这一天是当年的第几天

import java.util.Scanner;

class Demo11Month 
{
	public static void main(String[] args) 
	{
        Scanner scan = new Scanner(System.in);
        
		System.out.println("请您输入年份");
		int year = scan.nextInt();//输入年份
		System.out.println("请您输入月份");
		int month = scan.nextInt();//输入几月
		System.out.println("请您输入日子");
		int day = scan.nextInt();//输入几号

		int sumDays = 0;//记录总天数
		switch(month){
			case 12:
				sumDays += 30;
			case 11:
				sumDays += 31;
			case 10:
				sumDays += 30;
			case 9:
				sumDays += 31;
			case 8:
				sumDays += 31;
			case 7:
				sumDays += 30;
			case 6:
				sumDays += 31;
			case 5:
				sumDays += 30;
			case 4:
				sumDays += 31;
			case 3:
                if(year%4==0&&year%100!=0||year%400==0){//判断是否为闰年
                   sumDays += 29; 
                }else{
					sumDays += 28;
                }
			case 2:
				sumDays += 31;
			case 1:
				sumDays += day;
		}
		System.out.println("今天是"+year+"年"+month + "月" + day + "日，为本年的第"+sumDays+"天");
		System.out.println("Hello World!");
		}
}

2.6.4 循环结构1 for

反复执行特定程序

循环语句的四个组成成分

  • 初始化部分(init_statement)
  • 循环条件部分（test_exp)
  • 循环体部分（body_statement)
  • 迭代部分(alter_statement)

for 循环执行演示

for(int i = 1(第一步);i <= 100(第二步);i++(第四步))
{
    System.out.println(i);(第三步)
}

例题 输出十行hello world

for(int i = 1;i<=10;i++){
    System.out.println(i);
}

例题 遍历100以内的偶数

int sum;//记录总和
int count;
for(int i = 0;i<=100;i+=2){
    System.out.println(i);
    sum += i;
    count++;
}
System.out。println("总和为："+sum);
System.out。println("偶数的个数为："+count);

例题 遍历1-150倍数打印

编写程序从1循环到150，并在每行打印一个值，

另外在每个3的倍数行上打印出"foo"

在每个5的倍数行上打印"biz"

在每个7的倍数行上打印输出"baz"

class Demo12for{
    public static void main(String[] args){
        for(int i = 1;i<=150;i++){
            if(i%3==0){//判断3
                System.out.print("foo "+i);
            }else if(i%5==0){//判断5
                System.out.print("biz "+i);
            }else if(i%7==0){//判断7
				System.out.print("baz "+i);
			}else{
				System.out.println(i);
            }
        }
        System.out.println("Hello World!");
    }
}

例题 计算最大公约数与最小公倍数

输入两个正整数m和n，求其最大公约数和最小公倍数。

比如：12和20的最大公约数是4，最小公倍数是60。

说明： break 关键字的使用

总结：结束循环的方式都有哪些?

  1. 循环条件中不满足，返回false
  2. 使用break关键字
class  ForTest1{
    public static void main(String[] args){
        int m = 12;
        int n = 20;
        
        //获取连个数的较小值
        int min = (m>n)?n:m;
        
        for(int i = min;i>=1;i--)
            if(m%i==0&&n%i==0){//判断最大公约数
                System.out.println("最大公约数："+i);
                break;
            }
                
        //获取两个数的较大值
        int max = (m>n)?m:n;
        for(int i = max; i <=m*n ;i++){
            if(i%m==0&&i%n==0){//判断最小公倍数
                System.out.printlnm("最小公倍数："+i);
                break;
            }
        }
        
    }

2.6.5 循环结构2： while循环

for循环和while循环是可以相互转换的

关于初始化条件部分

while循环在执行结束后

初始化条件中涉及到的变量仍然可用

public class WhileLoop{
    public static void main(String args[]){
        int result = 0;
        int i = 1;(第一步)
        while (i <= 100){(第二步)
            result += 1;(第三步)
            i++;(第四步)
        }
        System.out.println("result = " = result);
    }
}

while循环与for循环的i的作用域不同

2.6.6 循环结构3：do-while循环

public class DoWhileLoop
{
    public static void main(String args[])
    {
        int result = 0;
        int i = 1;
        do
        {
            result += i;
            i++;
        }while(i <= 100);
        System.out.println("result = " + result);
    }
}

说明

do-while至少执行一次循环体

从事开发应用频次较低

//遍历100以内的偶数
int i = 0;
int sum =0;
int count = 0;
do{
    if(i%2==0){
        System.out.println(i);
        sum+=i;
        count++;
    }
    i++;
}while(i<=100);

2.6.7 嵌套循环

  1. 将一个循环结构A声明在另一个循环结构B的循环体中，则构成了嵌套循环

A：内层循环

B：外层循环

  1. 外层循环控制行数，内层循环控制列数

  2. 如果外层循环循环次数为m次，内层循环循环次数为n次，则可以理解为内层循环的循环体可以执行m*n次

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




### 2.6.8 特殊流程控制语句==(break)==与==(continue)==

使用场景

- break只能用于switch语句和循环语句中。
- continue 只能用于循环语句中。


continue：结束当次循环

break：结束当前循环 结束离break最近的for

```java
class Demo{
 public static void main(String[] args){
     for(int i = 1; i <= 10;i++){
         if(i % 4 == 0){
             //break;//当前循环结束
             continue;//本次循环结束
             //System.out.println("今晚迪丽热巴要约我");
         }
         System.out.print(i);
     } 
 }
}

break、continue之后不能声明其他语句，程序永远不会执行其后的语句，否则会报错。

break越级结束指定标签对应的for

class Demo{
    public static void main(String[] args){
        label:for(int i = 1; i <= 10;i++){
            for(int j = 1; j <= 10; j++){
                if(i % 4 == 0){
                //break;//当前循环结束
                continue label;//本次循环结束
                //System.out.println("今晚迪丽热巴要约我");
            }
            System.out.print(i);
            }
        } 
    }
}

2.6.9 循环语句无限循环for(;与while(true)

从键盘读入个数不确定的整数，并且判断读入的正数与负数的个数，输入为0时结束程序

无限循环的存在的原因是并不知道循环多少次

需要根据循环体内部的某些条件来控制循环的结束

for(;;)//while(true){
    Scanner.out.println("");
    int num = scan.nextInt();
    if(num>0)
        positiveNumber++;
    else if(num<0)
        negativeNumber++;
    else
       break;
}

打印**

/*
******
******
******
******
******
*/
class Demo14{
    public static void main (String[] args){
        for(int i = 0 ; i < 5 ; i++){
            for(int j = 0;j < 6 ; j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

打印倾斜**

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

类似于数轴

打印倒着的**

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

打印上下两种部分**

打印**要注意i与j的数量，分析内层j与外层循环的关系

public class PrintStarTest {
    public static void main(String[] args) {
        /*
           i    j
    *****  1    5
    ****   2    4
    ***    3    3
    **     4    3
    *      5    1   所以内层循环每次都是从j=1打印到6-i次为止
         */
        for(int i = 1; i <= 5 ; i++){
            for(int j = 1; j <= 6-i ; j++){
                System.out.print("*");
            }
            System.out.println();
        }

        /*
        上半部分    i   j(-)    k(*)
        ----*      1    4       1
        ---* *     2    3       2
        --* * *    3    2       3
        _* * * *   4    1       4
        * * * * *  5    0       5

        下半部分   i     j      k
        * * * *   1     4      0
        -* * *    2     3      1
        --* *     3     2      2
        ---*      4     1      3
         */

        //上半部分的打印
        for(int i = 1; i <= 5 ; i++){
            for(int j = 1; j <= 5-i ; j++){
                System.out.print("-");
            }
            for(int k = 1; k <= i ; k++){
                System.out.print("* ");
            }
            System.out.println();
        }
        System.out.println("######################");
        //下半部分的打印
        for(int i = 1; i <= 4 ; i++){
            for(int j = 1; j < i ; j++){
                System.out.print(" ");
            }
            for(int k = 1; k <= 5-i ; k++){
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

2.6.10 嵌套循环的经典例题

九九乘法表

class Demo{
    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();
    }
    }
}

100以内所有的质数自然数

题目：100以内的所有质数

质数（或素数）：只能被1和他本身整除的自然数

比如：2, 3, 5,7,11,13,17,19,23，… 59

class Demo{
    public static void main(String[] args){
        boolean isFlag = true;
        for(int i = 2;i <= 100; i++){    
            for(int j = 2;j < i;j++){
                if(i % j == 0){
					isFlag = false;
                }
            }
            //判断isFlag是否曾经被赋值为false
            if(isFlag){
                System.out.println(i);
            }
			
			isFlag = true;//重置
        }
    }
}

遍历100 000以内的质数，判断执行效率，利用毫秒数

public class PrimeNumberTest1 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        boolean isPrime = true;
        int count = 0;
        for(int i = 2; i < 100000 ; i++){
            for(int j = 2; j < Math.sqrt(i); j++){//优化1 j < i
                if (i % j == 0) {
                    isPrime = false;
                    break;//优化2
                }
            }
            if(isPrime){
                System.out.println(i);
                count++;
            }
            isPrime = true;
        }
        long end = System.currentTimeMillis();
        System.out.println("质数个数为:"+count);
        System.out.println("花费的总时间为(毫秒)：" + (end - start));
    }//17298-211
}

关于math.sqrt的理解

、

对于100以内的数可以说，取半就可以判断是否存在因子，但是50*2=100，

判断了2就无需在判断50，因此判断了10之后，就无需继续往后判断

03 数组

3.1 数组的概述

数组(Array)，是多个相同类型数据按一定顺序排列的集合，

并使用一个名字命名，

并通过编号的方式对这些数据进行统一管理。

数组的常见概念

  • 数组名
  • 下标(或索引)
  • 元素
  • 数组的长度

3.2 一维数组的使用

3.2.1数组的声明和初始化

格式：数据类型 变量名 = 变量值

int num = 10;
String str = "Hello";

//声明
String[] foods ;
//初始化
foods = new String[]{"拌海蜇","龙须菜","西湖醋鱼"};
//声明并初始化
//静态初始化：数组变量的赋值操作与数组元素的赋值操作同时进行
String[] names = new String[]{"李金鑫"，"刘志引"，"徐德三"};
//可以简写为：String[] names = {"李金鑫"，"刘志引"，"徐德三"};

//动态初始化：数组变量的赋值操作与数组元素的赋值操作分开进行
double[] prices = new double[5];

简单整理

数组的声明;

double[] prices = new double[]{2,5,6,2}; 静态数组
double[] prices = new double[5]; 动态数组
  
int[] arr = {1,2,3};类型推断

数组一旦初始化（不管是静态还是动态初始化，长度就已经确定了）

数组一旦初始化，(不管是静态还是动态初始化，其长度就是不可变的）

错误

//t[] arr = new double[5]{1,2,3,4,5};
//t[5] arr = new int[5];

3.2.2 如何调用数组的元素

通过角标的方式进行调用

角标从0开始

prices[0] = 12.3;

prices[1] = 23.4;

prices[5]越界报错

out of bounds exception

3.2.3 如何获得数组的长度

属性：length

System.out.println(prices.length)

3.2.4 如何遍历数组元素

for(int i = 0; i < names.length ; i ++){
    System.out.println(names[i]);
}

3.2.5 数组元素的默认初始化值

double[] prices = new double[5];
price[0] = 12.3;
prices[1] = 24.4;
System.out.println(price[2]);

int[] arr = new int[]{1,2,3,4};
SYstem.out.println(arr[0]);

以动态初始化值为例

数组元素类型 元素默认初始值
byte 0
short 0
int 0
long 0L
float 0.0F
double 0.0
char 0 或写为:’\u0000’(表现为空)
boolean false
引用类型 null

3.2.6 一维数组的内存解析

栈（stack）特点： 先进后出

堆（heap）

方法区

一个方法对应一个栈针

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-731rZwek-1596345581913)(images/image-20200727195800509.png)]

内存内的运行方式具体如图所示，在内存中，栈主要存储数组的索引，也就是数组的第一个值

然后数组的具体存储在堆中，通过赋值对栈与堆具体的数值不断更新

通过定义数组后，原来的索引失效，java会自动垃圾回收

当main函数执行完毕后，会自行发生垃圾回收

练习1

升景坊单间短期出租4个月，550元/月（水电煤公摊，网费35元/月），空调、卫生间、厨房齐全。屋内均是IT行业人士，喜欢安静。所以要求来租者最好是同行或者刚毕业的年轻人，爱干净、安静。

public class ArrayTest {
      public static void main(String[] args) {
      int[] arr = new int[]{8,2,1,0,3};
      int[] index = new int[]{2,0,3,2,4,0,1,3,2,3,3};
      String tel = "";
      for(int i = 0;i < index.length;i++){
            tel += arr[index[i]];
      }
      System.out.println("联系方式：" + tel);
      }
}

练习2

从键盘读入学生成绩，找出最高分，并输出学生成绩等级。

  1. 成绩>=最高分-10 等级为’A’
  2. 成绩>=最高分-20 等级为’B’
  3. 成绩>=最高分-30 等级为’C’
  4. 其余 等级为’D’

提示：先读入学生人数，根据人数创建int数组，存放学生成绩。

import java.util.Scanner;
/**
 * @author Jinxin Li
 * @create 2020-07-27 21:02
 * 从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
 * 	成绩>=最高分-10    等级为’A’
 * 	成绩>=最高分-20    等级为’B’
 * 	成绩>=最高分-30    等级为’C’
 * 	其余                        等级为’D’
 * 提示：先读入学生人数，根据人数创建int数组，存放学生成绩
 */
public class HomeWork3 {
    public static void main(String[] args) {
       Scanner scan = new Scanner(System.in);
       System.out.print("请输入学生人数");
       int studentsNum = scan.nextInt();

       //定义数组学生成绩
       int arr[] = new int[studentsNum];
       int i = 0;
       System.out.println("请您输入" + studentsNum + "个成绩");
       while(i < studentsNum){
            int studentScore = scan.nextInt();
            arr[i] = studentScore;
            i++;
        }

       //找出最高分
        int max = 0;
        for(int j = 0; j < arr.length; j++ ){
            if(arr[j] > max){
                max = arr[j];
            }
        }
        System.out.println("最高分是" + max);

        //判断输出学生成绩
        for(int j = 0;j < arr.length; j++){
            if(arr[j]>(max - 10)){
                System.out.println("student "+ j + " score is " + arr[j] + " grade is A");
            }else if(arr[j]>(max - 20)){
                System.out.println("student "+ j + " score is " + arr[j] + " grade is B");
            }else if(arr[j]>(max - 30)){
                System.out.println("student "+ j + " score is " + arr[j] + " grade is C");
            }else
                System.out.println("student "+ j + " score is " + arr[j] + " grade is D");
        }

    }
}

3.3 多维数组的使用

多维数组中主要讨论二维数组

3.3.1 二位数组的声明和初始化

静态初始化

int[][] arr = new int[][]{{1,2,3},{4,5},{6,7,8},{9,8,6,4}};

String[][] arr1 = new String[][]{{"陈伟霆","刘诗诗"},{"周笔畅"}};

动态初始化

//1
int[][] arr3 = new int[4][3];
//2
int[][] arr4 = new int[4][];
//继续定义arr4[0]第一个子数组
arr4[0] = new int[3];

/*
与一维数组的定义类似
double[] prices = new double[5];
*/

//也是正确的结构
int arr5[] = new int[5];
int arr6[][] = new int[5][7];
int[] arr7[] = new int[5][7];

关于动态初始化2

arr4[0][0] = 10;
//无指针异常

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4EwF5n8Q-1596345581914)(images/image-20200728102930202.png)]

3.3.2 二维数组元素的调用

通过角标的使用调用二维数组的元素

System.out.println(arr[1][2]);

arr3[4][3] = 10;

3.3.3 二维数组的长度

System.out.println(arr3.length);
//4，二维数组外层数组的长度
System.out.println(arr[0].length);
//3, 二维数组内层数组的长度

3.3.4 二维数组的遍历

for(int i = 0 ; i < arr1.length ; i++){
    for(int j =0 ; j < arr1[i].length; j++)
    {
        System.out.print(arr1[i][j] +"\t");
    }
    System.out.println();
}

3.3.5 二位数组元素的默认初始化值

强类型 = 赋予什么类型，使用什么类型

对于二维数组来说，约定称谓：

外层元素，比如：arr1[0],arr1[1]

存储代表的一维数组的地址值（类型）

内层元素：比如：arr1[0][1] arr1[1][0]

存储与一维数组一样

外层地址打印输出地址+

int[][] arr1 = new int[4][4]
Ststem.out.println(arr1[0]);//外层数组打印输出地址
//引用类型默认初始化类型为null
int[][] arr3 = new int[4][];
System.out.println(arr3[0]);//null
System.out.println(arr3[0][0]);//空指针异常

arr3[0] = new int[4];
arr3[1] = new int[]{1,2,3}
arr3[2] = new int[5];
arr3[3] = new int[6];

3.3.6 二维数组的内存解析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0IZZw8s0-1596345581916)(images/image-20200728182924337.png)]

练习2 求数组所有元素的和

获取arr数组中所有元素的和。

提示：使用for的嵌套循环即可。

j i j = 0 j = 1 j = 2 j = 3
i = 0 3 5 8 -
i = 1 12 9 - -
i = 2 7 0 6 4 
/**
 * @author Jinxin Li
 * @create 2020-07-28 18:31
 * 求数组中元素的和
 */
public class SumArrays {
    public static void main(String[] args) {
        int[][] array = new int[][]{{3,5,8},{12,9},{7,0,6,4}};

        int sum = 0;//定义求和
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                sum += array[i][j];
            }
        }
        System.out.println("和为：" + sum);
    }
}

练习3 判断是否成立

类型相同,模式相同
声明：int[] x,y[]; 在给x,y变量赋值以后，以下选项允许通过编译的是： 
a )   x[0] = y;        no
b)    y[0] = x;        yes
c)    y[0][0] = x;     no
d)    x[0][0] = y;     no
e)    y[0][0] = x[0];  yes
f)    x = y;           no

提示：
一维数组：int[] x  或者int x[]   
二维数组：int[][] y 或者  int[] y[]  或者 int  y[][]

赋值符号左右两边类型相同

练习4 10行杨辉三角 二维数组

  1. 第一行有 1 个元素, 第 n 行有 n 个元素

  2. 每一行的第一个元素和最后一个元素都是 1

  3. 从第三行开始, 对于非第一个元素和最后一个元素的元素。即：

//从第三行开始，对于非第一个元素，数等于左上角元素+顶上元素
yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-unTL5wjQ-1596345581918)(images/image-20200728114200227.png)]

package AfterClass;

/**
 * @author Jinxin Li
 * @create 2020-07-28 14:19
 */
public class YangHuiTriangle {
    public static void main(String[] args) {
        int[][] arr = new int[10][];

        //定义数组形状，赋值为0
        for (int i = 0; i < arr.length; i++){
            for (int j = 0; j <= i; j++) {
                arr[i] = new int[i+1];//每一个内层数组都有i+1的元素
            }
        }

        //为外层赋值
        for(int i = 0; i < arr.length; i++){
            arr[i][0] = 1;
            arr[i][i] = 1;
        }

        //为内层赋值
        for(int i = 2; i <arr.length;i++){
            for (int j = 1; j < arr[i].length-1; j++) {//最后一个数与第一个数不需要赋值
                arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
            }
        }

        //输出数列
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

练习 5 各不相同的彩票随机数

创建一个长度为6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值。同时，要求元素的值各不相同。 Math.random()

package AfterClass;

/**
 * @author Jinxin Li
 * @create 2020-07-28 8:25
 * 创建一个长度为6的int型数组，
 * 要求数组元素的值都在1-30之间，且是随机赋值。
 * 同时，要求元素的值各不相同。 Math.random()
 */
public class ChapterPractice {
    public static void main(String[] args) {
        int[] arr = new int[20];

        //赋值
        for(int i = 0;i < arr.length; i++){
                arr[i] = (int)(Math.random()*30 + 1);
                for (int j = 0; j < i; j++){
                    if(arr[i] == arr[j]){
                        i--;//利用i--表示返回思想
                        break;
                    }
                }
        }
        //输出
        for(int i = 0;i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

练习 6 回形数

打印一个5的回形数

1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

练习7 赋值与复制

使用简单数组

(1)创建一个名为ArrayTest的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。

(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。

(3)显示array1的内容。

(4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)。打印出array1。 array2 = array1;

public class ArrayTest {
    public static void main(String[] args) {
        
        int[] arr1,arr2;

        //静态初始化8个素数
        arr1 = new int[]{2,3,5,7,11,13,17,19};
        System.out.println("显示arr1的值");
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i] + "\t");
        }
        System.out.println();

        //赋值arr2
        arr2 = arr1;//单纯的传递地址，并没有new出新数列
        System.out.println("显示arr2的值");
        for (int i = 0; i < arr2.length; i++) {
            if(i%2 == 0) {
                arr2[i] = i;
            }
            System.out.print(arr2[i] + "\t");
        }
        System.out.println();

        System.out.println("显示arr1的值");

        for (int i = 0; i < arr1.length; i++) {
            System.out.print( arr1[i] + "\t");
        }
    }
}

结果：

显示arr1的值
2 3 5 7 11 13 17 19
显示arr2的值
0 3 2 7 4 13 6 19
显示arr1的值
0 3 2 7 4 13 6 19
Process finished with exit code 0

可以看出arr2改变之后，arr1也进行了改变，两者赋值给予的是地址

类似于，放置快捷方式

如果是复制才可以进行真正的赋值操作

数组的复制操作

//复制arr1到arr2
arr2 = new int[arr1.length];
for(int i = 0; i <arr2.length; i++){
    arr2[i] = arr1[i]
}

3.4 数组中涉及到的常见算法

3.4.1 数组元素的赋值（杨辉三角，回形数）

见上文

3.4.2 求数值的最大值，最小值，总和，平均数

见上文

3.4.3 数组的赋值、反转，查找（线性查找，二分法查找）

反转操作

package AfterClass;

/**
 * @author Jinxin Li
 * @create 2020-07-28 19:18
 * 反转数组
 * int[] arr1 = new int[]{3,4,5,3,6,23,6,84,4};
 */
public class ReverseArray {
    public static void main(String[] args) {
        int[] arr1 = new int[]{3,4,5,3,6,23,6,84,4};
//        打印数组
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i] + "\t");
        }

        System.out.println();
//        method1
        for (int i = 0; i < arr1.length/2; i++) {//交换到一半即可，除法向上取整数，所以不用担心
            int temp = arr1[i];
            arr1[i] = arr1[arr1.length-1-i];//两端交换，注意-1为最后一位索引，然后逐步往中间靠拢
            arr1[arr1.length-1-i] = temp;
        }

        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i] + "\t");
        }
        System.out.println();
//        method2
        for (int i = 0,j = arr1.length; i < arr1.length/2; i++,j--) {//两边同时走
            int temp = arr1[i];
            arr1[i] = arr1[j-1];
            arr1[j-1] = temp;
        }
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i] + "\t");
        }
    }
}

查找操作-线性查找

package AfterClass;

/**
 * @author Jinxin Li
 * @create 2020-07-28 19:33
 * 线性查找
 */
public class LineSearch {
    public static void main(String[] args) {
        int[] arr3 = new int[]{3,14,5,13,6,23,16,84,4};

//        boolean Flag = true;//定义判断没找到的标志
        int i = 0;//此处把y放在外面
        for (; i < arr3.length; i++) {
            if(arr3[i] == 100){
                System.out.println("您要找的数"+arr3[i]+"的索引是"+i);
//                Flag = false;
                break;
            }

//        if(Flag){
//            System.out.println("未找到您要搜索的数值");
//        }
        }
        if(i == arr3.length){//若没有找到
            System.out.println("未找到您要搜索的数值");
        }
    }
}

二分法需要在有序数组中进行查找

package AfterClass;

/**
 * @author Jinxin Li
 * @create 2020-07-28 19:46
 */
public class BinarySearch {
    public static void main(String[] args) {
        int[] arr4 = new int[]{-99, -54, -2, 0, 2, 33, 43, 256, 999};
        boolean isFlag = true;
        int number = 256;
        int head = 0;//首索引位置
        int end = arr4.length - 1;//尾索引位置
        while(head <= end){
            int middle = (head + end) / 2;
            if(arr4[middle] == number){
                System.out.println("找到指定的元素，索引为：" + middle);
                isFlag = false;
                break;
            }else if(arr4[middle] > number){
                end = middle - 1;
            }else{//arr4[middle] < number
                head = middle + 1;
            }
        }

        if(isFlag){
            System.out.println("未找到指定的元素");
        }
    }
}

3.4.4 数组元素排序算法

排序

假设含有n个记录的序列为{R1，R2，…,Rn},

其相应的关键字序列为{K1，K2，…,Kn}。

将这些记录重新排序为{Ri1,Ri2,…,Rin},

使得相应的关键字值满足条Ki1<=Ki2<=…<=Kin,这样的一种操作称为排序。

通常来说，排序的目的是快速查找。

排序算法的优劣

1.时间复杂度：分析关键字的比较次数和记录的移动次数

2.空间复杂度：分析排序算法中需要多少辅助内存

3.稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，

则称这种排序算法是稳定的{4,4-1}，排完序列发现{4-1,4}称为不稳定的

排序方法分类

内部排序：整个排序过程不需要借助于外部存储器（如磁盘等），所有排序操作都在内存中完成。

外部排序：参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助于外部存储器（如磁盘）。外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成。

十大内部排序方法

  • 选择排序
  • 直接选择排序、堆排序
  • 交换排序
  • 冒泡排序、快速排序
  • 插入排序
  • 直接插入排序、折半插入排序、Shell排序
  • 归并排序
  • 桶式排序
  • 基数排序

快速排序

冒泡排序（会写）

package AfterClass;

/**
 * @author Jinxin Li
 * @create 2020-07-28 16:15
 * 冒泡排序
 */
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = new int[]{23,34,56,234,56,34,45,89,54,69};
        for (int i = 0; i < arr.length-1; i++) {//关于length - 1 为长度
            for (int j = 0; j < arr.length-1-i; j++) {//
                if(arr[j] > arr[j+1]) {
                    int temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }
}

3.5 Arrays工具类的使用

1 boolean equals(int[] a,int[] b) 判断两个数组是否相等。
2 String toString(int[] a) 输出数组信息。
3 void fill(int[] a,int val**)** 将指定值填充到数组之中。
4 void sort(int[] a) 对数组进行排序。
5 int binarySearch(int[] a,int key) 对排序后的数组进行二分法检索指定的值。
6 copyOf (int[],0,8) 复制 
package AfterClass;

import java.util.Arrays;

/**
 * @author Jinxin Li
 * @create 2020-07-28 20:00
 * Array工具类的使用
 */
public class ArraysTools {
    public static void main(String[] args) {
        int[] arr1 = new int[]{1,2,3,4,5};
        int[] arr2 = new int[]{1,2,3,4,5};
        System.out.println(arr1 == arr2);//false,两者地址不同

        //1.equals() 判断两个数组是否相等，顺序也在其中
        System.out.println(Arrays.equals(arr1,arr2));

        //2.toString()
        System.out.println(arr1);//打印数组的地址
        System.out.println(Arrays.toString(arr1));

        //3.fill()填充
        Arrays.fill(arr1,10);//自动补充
        System.out.println(Arrays.toString(arr1));

        //4.sort()//快速排序
        int[] arr3 = new int[]{3,14,5,13,6,23,16,84,4};
        Arrays.sort(arr3);
        System.out.println(Arrays.toString((arr3)));

        //5.binarySearch()
        // 前提：数组必须有序
        int index = Arrays.binarySearch(arr3,23);
        if (index >= 0){
            System.out.println("找到了指定元素，位置为：" + index);
        }else{
            System.out.println("未找到指定元素");
        }


    }
}

3.6 数组使用中的常见异常

package com.atguigu.java1;

/**
 * 测试数组中的常见异常
 * @author shkstart
 * @create 2020-07-28 16:26
 */
public class ArrayExceptionTest {
    public static void main(String[] args) {
        //1. 数组角标越界异常：ArrayIndexOutOfBoundsException
        int[] arr = new int[10];//0-9
        System.out.println(arr[9]);
//        System.out.println(arr[10]);//越界
//        System.out.println(arr[-10]);//越界

        //2. 空指针异常：NullPointerException
        //情况1：
//        int[] arr1 = new int[10];
//        arr1 = null;
//        System.out.println(arr1[0]);

        //情况2：
//        int[][] arr2 = new int[5][];
//        System.out.println(arr2[0][0]);


        //情况3：
        String[] arr3 = new String[5];
        System.out.println(arr3[0].toString());
    }
}

04 面向对象编程（上）

4.1面向对象与面向过程

学些面向对象的三个主线（老师总结）

  • Java类及类的成员：属性 方法 构造器 代码块 内部类
  • 面向对象的三大特征： 封装 继承 多态
  • 其他关键字：this super import package static final abstract interface

面向过程与面向对象

面向过程（POP）与面向对象（OOP）

二者都是一种思想，面向对象是相对于面向过程而言的。

二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。

面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。

面向对象的三大特征

  • 封装 (Encapsulation)
  • 继承 (Inheritance)
  • 多态 (Polymorphism)

面向对象：Object Oriented Programming

面向过程：Procedure Oriented Programming

4.2 Java语言的基本元素 类和对象

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

4.2.1 类与对象

类：是对一类事物的描述，是抽象的、概念上的定义

对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)

“万事万物皆对象”

String有两种方式

String str1 = "Hello";
String str2 = new String(orginal:"Hello")

4.2.2 设计类 其实就是设计类内部成员

属性：对应类中的成员变量

成员变量 = field = 域 = 字段

行为：对应类中的成员方法

方法 = 成员方法 = 函数 = 成员函数 = method

//设计类
class Phone{//类
    //属性
    String name;//品牌名
    double price;//价格

    //类中的方法
    public void call(){
        System.out.println("打电话");
    }

    public void sendMessage(String message){
        System.out.println("发出的信息为：" + message);
    }

}

4.3 对象的创建和使用

对类的实例化 = 创建累的对象

//创建Phone的对象

public static void main(String[] args) {
        //创建Phone的对象
        Phone p1 = new Phone();
        System.out.println("品牌名：" + p1.name + ", 价格为：" + p1.price);

        //通过"对象.方法" 或 "对象.属性"的方式调用功能，完成设计
        p1.name = "huawei p40 pro";
        p1.price = 8000.0;

        System.out.println("品牌名：" + p1.name + ", 价格为：" + p1.price);

        p1.call();
        p1.sendMessage("有内鬼，停止交易！");

        System.out.println("##########################");
    //创建第二个对象
        Phone p2 = new Phone();
        p2.name = "xiaomi 10";

        Phone p3 = p1;
        p3.price = 7000.0;
        System.out.println(p1.price);
    }

通过“对象.方法“ 或 ”对象.属性“的方式调用功能

面向对象编程思想落地的实现

步骤1：创建类，设计类的成员：属性，方法

步骤2：创建类的对象（或 类的实例化）

步骤3：调用“对象.方法” 与 “对象.属性”

4.3.1 对象的内存解析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oh3Gjyc0-1596345581920)(images/image-20200729102502319.png)]

内存解析 对象名保存栈空间中

对象实体 也保存在堆空间中

对象的属性也保存在堆空间中

4.3.2 创建类的多个对象

创建类的多个对象。每个对象就拥有一套类的属性

当修改其中某一个对象的属性a，不会影响其他对象。

如果将一个对象的引用赋值给另一个对象的引用。则表示两个引用同时指向了堆空间的同一个对象实体

4.4 类中的属性的声明

4.4.1 变量的分类

  • 1）按数据类型来分：基本数据类型 （8种） vs 引用数据类型（数组、类、接口）
  • 2）按在类中声明的位置： 成员变量 vs 局部变量
  •      成员变量：直接声明在类中。

  •      局部变量：方法内、构造器内、代码块内、方法的形参、构造器的形参等

4.4.2 成员变量（类中属性）与局部变量（方法内）

成员变量与局部变量上文可见，直接上代码

public class PersonTest {//测试类

    public static void main(String[] args) {
        Person p1 = new Person();
        System.out.println(p1.name);
        System.out.println(p1.age);
        System.out.println(p1.gender);

        p1.eat("鱼香肉丝");

        p1.name = "李金鑫";
    }
}


class Person{//类
    //属性（或成员变量）
    String name;
    int age;
    boolean gender;//true:女性  false：男性
    //方法
    public void eat(String food){//food:形参。形参属于局部变量
        System.out.println("我喜欢吃：" + food);
    }

    public void sleep(){
        int minHour = 6; //属于局部变量
        int maxHour = 10;//属于局部变量
        System.out.println("每天睡眠建议不要少于" + minHour + ",但是也不要睡的过多。建议不要超过" + maxHour + "小时");
    }
}

相同点：

都是变量，定义的格式相同：数据类型 变量名 = 变量值

先声明，后使用

变量都有其作用域。超出作用域就失效

不同点：

① 关于权限修饰符的使用（了解）

成员变量声明前可以使用不同的权限修饰符进行修饰。比如：private \ 缺省 \ protected \ public

局部变量不能使用权限修饰符进行修饰。

② 关于变量赋值的说明

成员变量可以显式赋值，也可以使用默认初始化值

局部变量必须在调用之前显式赋值。因为其没有默认初始化值

对于成员变量默认初始化值的情况：

  • 整型，默认值为：0
  • 浮点型：默认值为：0.0
  • char型：默认值为：0 或 ‘\u0000’
  • boolean型：默认值为：false
  • 引用数据类型：默认值为null

③ 在类中声明的位置不同

成员变量：直接声明在类内部

局部变量：声明在方法内、构造器内、代码块内、方法的形参、构造器的形参等

④ 在内存结构中的位置不同

成员变量：声明在堆空间中

局部变量：声明在栈空间中

4.5 类中的方法的声明

4.5.1 方法声明的整体格式

权限修饰符 返回值类型 方法名（参数类型1 参数名1，参数类型2 参数名2，…）

//方法体

说明：

<1> 权限修饰符：可以使用4种不同的权限修饰来修饰方法。比如：private \ 缺省 \ protected \ public

暂时大家在声明方法时，可以默认都声明为：public

可以表明结构被调用时的权限的大小

<2> 返回值类型

  • 没有返回值，使用void表示。比如：Arrays的sort（）

    Arrays.sort(arr)

  • 有具体的返回值类型,声明了返回值类型 可以是任意的基本数据类型，或者引用数据类型

    Arrays.binarySearch(int[] arr,int target);
Arrays.equals(int[] arr,int[] arr1);
Math.random();
sqrt(double value)

有具体的返回值类型的方法中，一定会使用return + 变量/常量的方法，满足具体类型的数据

有返回值必有返回类型；一定会使用return

注意点：

返回值会产生自动类型提升

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BeYKeoYg-1596345581920)(images/image-20200729113917995.png)]

4.5.2 方法名

属于标识符，命名时满足标识符的规范

4.5.3 形参列表

可以再声明方法时，在（）括号中存入该方法体在执行过程中必要的数据

互相之间加逗号

举例子

Arrays.binarySearch(int[] arr, int target);
Arrays.equals(int[] arr, int[] arr1);
Math.random();//这个在调用时就不要添加形式参数
sqrt(double value);

4.5.4 方法体

方法执行的结构

此外方法还可以使用一些关键字进行修饰

static

abstract

final

方法还可以抛出异常类型，异常类型见

声明方法时是否需要返回值类型，是否需要形参列表

看题目的要求

具体问题具体分析

4.5.5 return 的使用

<1> 一旦执行此关键字，就结束方法的执行

public void printNumber(){
    for(int i = 1; i <= 100; i++){
        if(i == 10){
            return;//在此处执行return之后，程序直接结束，将不会再执行下面的sout操作
        }
        System.out.println(i);
    }
}

<2> 在有返回值类型的方法中，使用return + 变量的结构，返回需要的数据类型对应的数据

public class UserTest {
    public static void main(String[] args) {
        int[] arr = new int[]{45,63,5,5,34,57};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

        User u1 = new User();
        u1.eat("水煮鱼");

        int years = u1.studyYears();
        System.out.println(years);//12

        System.out.println("############");
        u1.printNumber();
    }
}

class User{
    //属性
    String name;
    int age = 1;

    //方法的声明
    public void eat(String food){//food:形参。形参属于局部变量
        System.out.println("我喜欢吃：" + food);
    }

    public void sleep(){
        int minHour = 6; //属于局部变量
        int maxHour = 10;//属于局部变量
        System.out.println("每天睡眠建议不要少于" + minHour + ",但是也不要睡的过多。建议不要超过" + maxHour + "小时");
        return;
    }

    public int studyYears(){
        byte years = 12;
        return years;
    }


    public void printNumber(){
        for(int i = 1;i <= 100;i++){

            if(i == 10){
                return;
            }

            System.out.println(i);

        }

        System.out.println("hello");
    }
}

方法可以调用方法

4.5.0练习3

对象数组题目

定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。

问题一：打印出3年级(state值为3）的学生信息。

问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息

提示：

  1. 生成随机数：Math.random()，返回值类型double;

  2. 四舍五入取整：Math.round(double d)，返回值类型long。

public class Practice5 {
    public static void main(String[] args) {
        //1.创建student类型的数组
        Student[] stus = new Student[20];//自己定义的类，引用型，可以给自己赋值

        //2.通过循环给每个数组元素赋值
        for (int i = 0; i < stus.length; i++) {
            stus[i] = new Student();
            stus[i].number = i + 1;
            stus[i].state = (int) (Math.random() * 6 + 1);
            stus[i].score = (int) (Math.random() * 101);
            stus[i].Information();
        }

        //打印三年级学生的信息
        for (int i = 0; i < stus.length; i++) {
            if (stus[i].state == 3) {
                System.out.println("三年级的学生的成绩");
                stus[i].Information();
            }
        }

        System.out.println("学生成绩排序");

        //使用冒泡排序排序学生成绩
        for (int i = 0; i < stus.length-1; i++) {
            for (int j = 0; j < stus.length-1-i; j++) {
                if (stus[j].score > stus[j+1].score) {
                    Student temp = stus[j];
                    stus[j] = stus[j+1];
                    stus[j+1] = temp;
                }
            }
        }
        for (int i = 0; i < stus.length; i++) {
            stus[i].Information();
        }
    }
}

/**
 * 定义学生类
 */
class Student{
    int number;
    int state;
    int score;

    public void Information(){
        System.out.println("number: " + number + " state：" + state + " score：" + score);
    }
}

4.6 再谈方法

4.6.1 方法的重载

重载的概念：

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可

重载的特点：

与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

总结：“两同一不同”：相同类中，相同方法名

参数列表不同：参数个数不同，参数的类型不同

方法的重载与权限修饰符，返回值类型，形参名都没有关系

如何确定调用了一个类的那个方法？

  • 通过方法名
  • 通过形参列表的个数和类型

重载实例

/**
 * @author Jinxin Li
 * @create 2020-07-29 20:37
 * 定义三个重载方法max()，
 * 第一个方法求两个int值中的最大值，
 * 第二个方法求两个double值中的最大值，
 * 第三个方法求三个double值中的最大值，并分别调用三个方法。
 */
public class HomeWork2 {
    public static void main(String[] args) {
        HomeWork2 test = new HomeWork2();

        System.out.println(test.max(1, 2));
        System.out.println(test.max(0.5, 8.7));
        System.out.println(test.max(0.7, 10.9, 6.8));
    }

    public int max(int m, int n){
        return m > n ? m : n;
    }

    public double max(double m, double n){
        return m > n ? m : n;
    }

    public double max(double m, double n, double l){
        return  m > n ? (m > l ? m : l) : (n > l ? n : l);
    }
}

4.6.2 对象的使用：匿名对象的使用

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

如：new Person().shout();

使用情况

如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。

我们经常将匿名对象作为实参传递给一个方法调用。

package AfterClass;

/**
 * @author Jinxin Li
 * @create 2020-07-29 19:00
 * 匿名调用
 */
public class ConcealableNameTest {
    public static void main(String[] args) {
        new CallPhone().PhoneCalling();//匿名调用
    }
}

class CallPhone{
    int PhoneNumber = 12231;
    public void PhoneCalling(){
        System.out.println(PhoneNumber);
    }
}

4.6.3 可变个数的形参

测试java中方法的可变形参的使用

public void sum(int i){
    "普通形参的方法".sout
}
public void sum(int ...i){//可变形参的形式
    "可变形参的方法".sout
}

格式：数据类型 … 参数名

说明：

  • 在调用可变形参的方式时，可以给可变形参赋值的参数个数为：0个，1个，2个，…
  • 在main函数进行调用时，优先寻找存在指定参数个数的重载方法进行代入，但是一般如果已经存在可变形参的方法，就不会继续编写其重载的其他方法
  • 可变形参的方法在同一个类中，能够与相同方法名的多个方法构成重载
  • 可变形参的方法a 与 参数同类型的数组的形参的方法b，不能在一个类中同时声明,不会发生重载
//可变形参与数组
public void sum(int ...arr){
    System.out.println("可变形参的方法");
    for(int i = 0; i < arr.length;i++){
        System.out.println(arr[i]);
    }
}

public void sum (int[] arr){
    for(int i = 0;i < arr.length;i++){
        System.out.println(arr[i]);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gWyaClDO-1596345581922)(images/image-20200731182018027.png)]

可以看到其实可变个数的形参其实在编译器中被视为数组，靠的是数组来进行处理不同个数的形参

  • 可变形参必须在参数列表的最后。（编译器不明白你少个）

其实可以理解，因为在参数列表中，如果你写在前面，则编译器无法判断你写在后面的数是否属于你的可变形参的数量。

  • 可变形参要求只有一个可变形参

4.6.3.0 数组的println(char[])

一般如果对于数组而言，数组打印的是地址


public class PrintArrayTest {
    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3};
        System.out.println(arr);//地址值

        char[] arr1 = new char[]{'a','b','c'};0.00
        System.out.println(arr1); //abc

        System.out.println(123.0);
        System.out.println("abc");
    }
}

而在println中存在char[] 数组类型，println能够直接打印

4.6.4 变量间的传递规则

基本数据类型 传递的是基本数据类型变量保存的数据值。

引用数据类型 传递的是引用数据类型变量保存的地址值。

形参：方法声明时，小括号内声明的参数

实参：方法调用时，实际传递过去的参数

<1> 方法的参数传递机制：值传递机制

交换1：方法内交换两个变量的值

public static void main(String[] args){
    int m = 10;
    int n = 20;
    System.out.println("m = " + m);
    System.out.println("n = " + n);
   
    //交换两个变量的值
    int temp = m;
    m = n;
    n = temp;
    
    System.out.println("m = " + m);
    System.out.println("n = " + n);
}

上面可以看出在main方法中，直接对参数进行

交换2：调用方法，实现变量的交换

//接上述程序
public class ValueTransferTest1 {
    main;
    int m = 10;
    int n = 20;
    
    //定义新的变量
    valueTransferTest1 test = new ValueTransferTest1();
    test.swap(m,n);
    
    sout.m;
    sout.n;
}

//定义交换的方法
public void swap(int m, int n){
    int temp = m;
    m = n;
    n = temp;
}
//结果并没有转换过来
  • 可以得出在上述方法中，参数并没有被转换过来
  • 在方法的使用中，对于基本数据类型来讲，将实参定义传入到方法中，与本来定义的变量不同，仅仅将数值传递过去，完全属于两套变量

例题3 方法的参数传递

package AfterClass;

/**
 * @author Jinxin Li
 * @create 2020-07-31 11:14
 */
public class ValueChange {
    public static void main(String args[]) {
        ValueChange test = new ValueChange();//创建新对象
        test.first();
    }
    public void first() {
        int i = 5;
        Value v = new Value();
        v.i = 25;
        second(v, i);
        System.out.println(v.i);
    }
    public void second(Value v, int i) {
        i = 0;
        v.i = 20;
        Value val = new Value();
        v = val;
        System.out.println(v.i + " " + i);
    }
}

class Value {
    int i = 15;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZlsXGnUd-1596345581924)(images/image-20200731200528077.png)]

4.6.4对象数组指定索引进行交换

/**
     * 交换stus数组中指定的index1和index2位置上的元素
     * @param stus
     * @param index1
     * @param index2
     */
    private void swap(Student[] stus,int index1,int index2){
        Student tempStudent = stus[index1];
        stus[index1] = stus[index2];
        stus[index2] = tempStudent;
    }

    //错误的写法
    public void swap(Student s1,Student s2){
        Student tempStudent = s1;
        s1 = s2;
        s2 = tempStudent;
    }

4.6.5 递归（recursion）

一个方法体内调用它自身

递归方法：一个方法体内调用它自身。

  • 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
  • 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
import java.io.File;

/**
 * @author shkstart
 * @create 2020-07-31 11:58
 *
 * 递归方法：一个方法体内调用它自身。
 * 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
 * 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
 */
public class RecurionTest {
    public static void main(String[] args) {
        RecurionTest test = new RecurionTest();
        System.out.println(test.getSum(100));
        System.out.println(test.getSum1(100));

        System.out.println(test.f(10));
    }

    //计算1-100自然数的和,并返回
    public int getSum(int num){
        int sum = 0;
        for(int i = 1;i <= num;i++){
            sum += i;
        }
        return sum;
    }

    //递归举例1：计算1-100自然数的和,并返回
    public int getSum1(int num){
        if(num == 1){
            return 1;
        }else{
            return num + getSum1(num - 1);
        }
    }

    //递归举例2:n!
    public int multiply(int num){
        if(num == 1){
            return 1;
        }else{
            return num * multiply(num - 1);
        }
    }

    //递归举例3:已知有一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),
    //其中n是大于0的整数，求f(10)的值。
    public int f(int n){
        if(n == 0){
            return 1;
        }else if(n == 1){
            return 4;
        }else{
            return 2*f(n - 1) + f(n - 2);
        }
    }
    //递归举例4:已知一个数列：f(20) = 1,f(21) = 4,f(n+2) = 2*f(n+1)+f(n),
    //其中n是大于0的整数，求f(10)的值。
    public int func(int n){
        if(n == 20){
            return 1;
        }else if(n == 21){
            return 4;
        }else{
            return func(n + 2) - 2 * func(n + 1);
        }
    }

    //递归举例5：斐波那契数列(Fibonacci)
    //  1  1  2  3  5  8  13  21  34  55
    //  规律：一个数等于前两个数之和： f(n) = f(n - 1) + f(n - 2)

    //递归举例6：汉诺塔

    //递归举例7:遍历指定文件目录下的所有文件名
    public void printFileName(File dir){
        if(dir.isFile()){//是文件
            System.out.println(dir.getAbsolutePath());
        }else{//是文件目录
            File[] files = dir.listFiles();
            for(int i = 0;i < files.length;i++){
                printFileName(files[i]);
            }

        }
    }
    //拓展：计算指定文件目录的大小、删除指定的文件目录

    //递归举例8:快速排序
}

4.7 面向对象特征之一：封装与隐藏、

private体现封装性

4.7.1 封装性的引入

我们在创建了类的对象以后，可以通过"对象.属性"的方式给对象的属性赋值。

此时，对象的属性的赋值需要满足相应的数据类型和取值范围。在此之外，实际问题中可能还有其他的一些限制条件。（比如：legs要求是正数、偶数、0~30）

那么该如何添加限制条件呢？

给属性提供公共（public）的setXxx()方法用于设置属性的值。在方法内，可以添加额外的限制条件。

给属性提供公共（public）的getXxx()方法用于获取属性的值。在方法内，可以添加额外的限制条件。

同时，将类中的属性xxx，设置为私有的（private）

public class AnimalTest {
    public static void main(String[] args) {
        Animal a1 = new Animal();
        a1.name = "大黄";
//        a1.age = 5;
        a1.setAge(5);
//        a1.legs = -4;
        a1.setLegs(4);

//        System.out.println(a1.legs);
        System.out.println(a1.getLegs() + "！！！");

        a1.info();
        a1.eat();
//        a1.sleep();
    }
}

class Animal{//动物类
    //属性
    String name;
    private int age;
    private int legs;//腿的个数

    //方法
    //给legs属性赋值的方法
    public void setLegs(int l){
        if(l >= 0 && l % 2 == 0 && l <= 30){
            legs = l;
        }else{
            System.out.println("输入的数据不合法！");
        }
    }

    //获取legs属性值的方法
    public int getLegs(){
        return legs;
    }

    //提供关于age属性的set和get方法
    public void setAge(int a){
        age = a;
    }

    public int getAge(){
        return age;
    }


    public void eat(){
        System.out.println("动物进食");
        sleep();
    }

    private void sleep(){
        System.out.println("动物休息");
    }

    public void info(){
        System.out.println("name = " +name + ", age = " + age + ", legs = " +legs);
    }
}

4.7.2 封装性的体现

封装性的体现：体现为4种不同的权限:（从小到大）private < 缺省 < protected < public

体现之一：私有化类的属性，提供公共的get和set方法，用于获取和设置此属性的值。

体现之二：私有化类的方法，表示此方法仅在类内部使用。不会暴露给类外使用。

体现之三：单例模式（涉及到私有化构造器）（后面讲）

通过使用4种不同的权限修饰类及类的内部结构，从而体现被修饰的结构在调用时的可见性的大小！

三 4种不同的权限修饰符：private < 缺省 < protected < public

4种不同的权限修饰符可以用来修饰类的内部结构：属性、方法、构造器、内部类。

修饰类的话，仅能使用2种权限：缺省 、 public

修饰符 类内部 同一个包 不同包的子类 同一个工程
private Yes
(缺省) Yes Yes
protected Yes Yes Yes
public Yes Yes Yes Yes

练习Person

创建程序,在其中定义两个类：Person和PersonTest类。定义如下：

用setAge()设置人的合法年龄(0~130)，用getAge()返回人的年龄。

在PersonTest类中实例化Person类的对象b，

调用setAge()和getAge()方法，体会Java的封装性。

Person
-age:int
+setAge(i: int) +getAge(): int 
package AfterClass;

/**
 * @author Jinxin Li
 * @create 2020-07-31 16:05
 */
public class PracticeAge {
    public static void main(String[] args) {
        Person b = new Person();
        System.out.println(b.getAge());

        b.setAge(1);
        System.out.println(b.getAge());
        b.setAge(23);
        System.out.println(b.getAge());
    }

}
class Person{
    private int age;
    public void setAge(int i){
        if(i >= 0 && i <= 130){
            age = i;
        }
    }
    public int getAge(){
        return age;
    }
}

4.8 类的成员之三 构造器（构造方法）

构造器的结构 修饰器+类名 不需要声明返回类型，因为不属于方法

构造器的作用

1.创建类的对象

2.给对象的属性初始化赋值

关于构造器的说明

构造器的默认权限取决于类的权限

如果没有显式声明类的构造器的话，则系统会默认提供一个空参的构造器

构造器声明格式：权限修饰符 类名（形参列表）

Person{
    String name;
    int age;
}

类中可以声明多个构造器，彼此之间构成重载

如果用户一旦显式的声明了类的构造器，则系统不再提供参数的构造器

类中一定会声明构造器

//在前面定义的Person类中添加构造器，利用构造器设置所有人的age属性初始值都为18。
package AfterClass;

/**
 * @author Jinxin Li
 * @create 2020-07-31 16:05
 */
public class PracticeAge {
    public static void main(String[] args) {
        Person b = new Person(9);
        System.out.println(b.getAge());
        b.setAge(23);
        System.out.println(b.getAge());
    }

}
class Person{
    private int age;
    public Person(int c){//声明构造器，不要返回值类型
        age = c;
    }
    public void setAge(int i){
        if(i >= 0 && i <= 130){
            age = i;
        }
    }
    public int getAge(){
        return age;
    }
}

A Java面向对象（预习教程）

A.1 继承

就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

//类的继承格式
class 父类{
}
class 子类 extends 父类{
}

A.2 构造器

子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

A.3 关键字 extends implements super this final

extends

在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

public class Animal { 
    private String name;   
    private int id; 
    public Animal(String myName, String myid) { 
        //初始化属性值
    } 
    public void eat() {  //吃东西方法的具体实现  } 
    public void sleep() { //睡觉方法的具体实现  } 
} 
 
public class Penguin  extends  Animal{ 
}

implements

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

super与this关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this关键字：指向自己的引用。

class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}
 
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}
 
public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();
    Dog d = new Dog();
    d.eatTest();
  }
}

final关键字

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IrAdD4SC-1596345581926)(images/image-20200730101844028.png)]

A.4 重写（Override)与重载（overload)

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如： 父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，只能抛出 IOException 的子类异常。

重载是随机应变

A.5 多态

多态是同一个行为具有多个不同表现形式或形态的能力。

多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

A.6 抽象类

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口

Java 包（Package）

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。

包的作用

  • 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
  • 如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
  • 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。

04-1 面向对象编程（上）

4.9 拓展知识 JavaBean

UML类图

4.10 构造器给对象赋值的位置

  1. 默认赋值
  2. 显式赋值
  3. 构造器中赋值
  4. 创建了对象以后，通过“对象，属性”或者对象。方法“的方式给属性赋值

赋值的先后顺序：

1,2,3,4；

4.11 this关键字的使用

可以调用属性，方法，构造器

我们在类的方法或类的构造器中，可以调用当前类中的属性跟方法

都常都省掉this

在特殊情况下this不可以省-同名

可以在类的构造器中显式的声明this构造器

this可以调用其他构造器

this()

为什么使用关键字？

this调用属性，方便给形参命名

当方法中定义的局部变量，包含形参

this调用构造器

new+构造器才调用对象

其他构造器是初始化一些操作

this必须声明在首行

在一个类的构造器中最多只能声明一个

谁调用方法，谁是this

4-10 关键字package

package放在源文件的开头

声明包名，属于标识符的一种，

在定义时需要满足标识符的命名规则，规范，见名知意

包名全小写

每“."一次，就代表一层文件目录

同一个包内不能有同名的类，接口

4-11 关键字 import导入

1.我们可以在package包声明和java类之间声明导入结构的

2.我们可以在当前类中，使用其他包下的结构

特例

lang包下不用导入，就可以使用

当使用包下的文件，达到五个时，会变成.*的方式，表示可以导入java.util的所有结构

子包，lang包下子包也需要导入

第五章 面向对象编程（中）

1.OOP特征二：继承性

1.1好处

1.2 格式

说明：

直接父类。间接父类

2.方法的重写

重载，两同一不同

测试方法的重写

（override、overwrite）

子类可以更大

权限应该更大

3.四种访问权限修饰符

4.关键字 super

你可能感兴趣的:(java基础,java)

  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
  • python语法——三目运算符 HappyRocking pythonpython三目运算符
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Java：爬虫框架 dingcho Javajava爬虫
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
  • python怎么将png转为tif_png转tif weixin_39977276
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • 00. 这里整理了最全的爬虫框架（Java + Python） 有一只柴犬 爬虫系列爬虫javapython
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
  • JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式androidjava常用设计模式
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
  • JavaScript `Map` 和 `WeakMap`详细解释 跳房子的前端 JavaScript原生方法javascript前端开发语言
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
  • 切换淘宝最新npm镜像源是 hai40587 npm前端node.js
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
  • 【Java】已解决：java.util.concurrent.CompletionException 屿小夏 java开发语言
    文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
  • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】） ok!ko 设计模式设计模式建造者模式java
    文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
  • jvm调优总结（从基本概念 到 深度优化） oloz javajvmjdk虚拟机应用服务器
    JVM参数详解：http://www.cnblogs.com/redcreen/archive/2011/05/04/2037057.html   Java虚拟机中，数据类型可以分为两类：基本类型和引用类型。基本类型的变量保存原始值，即：他代表的值就是数值本身；而引用类型的变量保存引用值。“引用值”代表了某个对象的引用，而不是对象本身，对象本身存放在这个引用值所表示的地址的位置。
  • 【Scala十六】Scala核心十：柯里化函数 bit1129 scala
    本篇文章重点说明什么是函数柯里化，这个语法现象的背后动机是什么，有什么样的应用场景，以及与部分应用函数(Partial Applied Function)之间的联系   1. 什么是柯里化函数 A way to write functions with multiple parameter lists. For instance def f(x: Int)(y: Int) is a
  • HashMap dalan_123 java
    HashMap在java中对很多人来说都是熟的；基于hash表的map接口的非同步实现。允许使用null和null键；同时不能保证元素的顺序；也就是从来都不保证其中的元素的顺序恒久不变。 1、数据结构     在java中，最基本的数据结构无外乎：数组 和 引用（指针），所有的数据结构都可以用这两个来构造，HashMap也不例外，归根到底HashMap就是一个链表散列的数据
  • Java Swing如何实时刷新JTextArea，以显示刚才加append的内容 周凡杨 java更新swingJTextArea
    在代码中执行完textArea.append("message")后，如果你想让这个更新立刻显示在界面上而不是等swing的主线程返回后刷新，我们一般会在该语句后调用textArea.invalidate()和textArea.repaint()。 问题是这个方法并不能有任何效果，textArea的内容没有任何变化，这或许是swing的一个bug，有一个笨拙的办法可以实现
  • servlet或struts的Action处理ajax请求 g21121 servlet
    其实处理ajax的请求非常简单，直接看代码就行了： //如果用的是struts //HttpServletResponse response = ServletActionContext.getResponse(); // 设置输出为文字流 response.setContentType("text/plain"); // 设置字符集 res
  • FineReport的公式编辑框的语法简介 老A不折腾 finereport公式总结
    FINEREPORT用到公式的地方非常多，单元格（以=开头的便被解析为公式），条件显示，数据字典，报表填报属性值定义，图表标题，轴定义，页眉页脚，甚至单元格的其他属性中的鼠标悬浮提示内容都可以写公式。 简单的说下自己感觉的公式要注意的几个地方：   1.if语句语法刚接触感觉比较奇怪，if(条件式子,值1,值2)，if可以嵌套，if(条件式子1，值1，if(条件式子2，值2，值3)
  • linux mysql 数据库乱码的解决办法 墙头上一根草 linuxmysql数据库乱码
    linux 上mysql数据库区分大小写的配置 lower_case_table_names=1 1-不区分大小写 0-区分大小写   修改/etc/my.cnf 具体的修改内容如下:   [client] default-character-set=utf8   [mysqld] datadir=/var/lib/mysql socket=/va
  • 我的spring学习笔记6-ApplicationContext实例化的参数兼容思想 aijuans Spring 3
    ApplicationContext能读取多个Bean定义文件，方法是： ApplicationContext appContext = new ClassPathXmlApplicationContext（ new String[]｛“bean-config1.xml”，“bean-config2.xml”，“bean-config3.xml”，“bean-config4.xml
  • mysql 基准测试之sysbench annan211 基准测试mysql基准测试MySQL测试sysbench
    1 执行如下命令，安装sysbench-0.5： tar xzvf sysbench-0.5.tar.gz  cd sysbench-0.5  chmod +x autogen.sh  ./autogen.sh  ./configure --with-mysql --with-mysql-includes=/usr/local/mysql
  • sql的复杂查询使用案列与技巧 百合不是茶 oraclesql函数数据分页合并查询
      本片博客使用的数据库表是oracle中的scott用户表;          -------------------  自然连接查询           查询 smith 的上司(两种方法) &
  • 深入学习Thread类 bijian1013 javathread多线程java多线程
    一．             线程的名字 下面来看一下Thread类的name属性，它的类型是String。它其实就是线程的名字。在Thread类中，有String getName()和void setName(String)两个方法用来设置和获取这个属性的值。 同时，Thr
  • JSON串转换成Map以及如何转换到对应的数据类型 bijian1013 javafastjsonnet.sf.json
            在实际开发中，难免会碰到JSON串转换成Map的情况，下面来看看这方面的实例。另外，由于fastjson只支持JDK1.5及以上版本，因此在JDK1.4的项目中可以采用net.sf.json来处理。 一.fastjson实例 JsonUtil.java package com.study; impor
  • 【RPC框架HttpInvoker一】HttpInvoker：Spring自带RPC框架 bit1129 spring
    HttpInvoker是Spring原生的RPC调用框架，HttpInvoker同Burlap和Hessian一样，提供了一致的服务Exporter以及客户端的服务代理工厂Bean，这篇文章主要是复制粘贴了Hessian与Spring集成一文，【RPC框架Hessian四】Hessian与Spring集成   在 【RPC框架Hessian二】Hessian 对象序列化和反序列化一文中
  • 【Mahout二】基于Mahout CBayes算法的20newsgroup的脚本分析 bit1129 Mahout
    #!/bin/bash # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information re
  • nginx三种获取用户真实ip的方法 ronin47
    随着nginx的迅速崛起，越来越多公司将apache更换成nginx. 同时也越来越多人使用nginx作为负载均衡, 并且代理前面可能还加上了CDN加速，但是随之也遇到一个问题：nginx如何获取用户的真实IP地址,如果后端是apache,请跳转到<apache获取用户真实IP地址>，如果是后端真实服务器是nginx，那么继续往下看。 实例环境： 用户IP 120.22.11.11
  • java-判断二叉树是不是平衡 bylijinnan java
    参考了 http://zhedahht.blog.163.com/blog/static/25411174201142733927831/ 但是用java来实现有一个问题。 由于Java无法像C那样“传递参数的地址，函数返回时能得到参数的值”，唯有新建一个辅助类：AuxClass import ljn.help.*; public class BalancedBTree {
  • BeanUtils.copyProperties VS PropertyUtils.copyProperties 诸葛不亮 PropertyUtilsBeanUtils
     BeanUtils.copyProperties VS  PropertyUtils.copyProperties  作为两个bean属性copy的工具类，他们被广泛使用，同时也很容易误用，给人造成困然；比如：昨天发现同事在使用BeanUtils.copyProperties copy有integer类型属性的bean时，没有考虑到会将null转换为0，而后面的业
  • [金融与信息安全]最简单的数据结构最安全 comsci 数据结构
          现在最流行的数据库的数据存储文件都具有复杂的文件头格式，用操作系统的记事本软件是无法正常浏览的，这样的情况会有什么问题呢？        从信息安全的角度来看，如果我们数据库系统仅仅把这种格式的数据文件做异地备份，如果相同版本的所有数据库管理系统都同时被攻击，那么
  • vi区段删除 Cwind linuxvi区段删除
    区段删除是编辑和分析一些冗长的配置文件或日志文件时比较常用的操作。简记下vi区段删除要点备忘。   vi概述    引文中并未将末行模式单独列为一种模式。单不单列并不重要，能区分命令模式与末行模式即可。   vi区段删除步骤： 1. 在末行模式下使用:set nu显示行号 非必须，随光标移动vi右下角也会显示行号，能够正确找到并记录删除开始行
  • 清除tomcat缓存的方法总结 dashuaifu tomcat缓存
    用tomcat容器，大家可能会发现这样的问题，修改jsp文件后，但用IE打开 依然是以前的Jsp的页面。 出现这种现象的原因主要是tomcat缓存的原因。 解决办法如下: 在jsp文件头加上 <meta http-equiv="Expires" content="0"> <meta http-equiv="kiben&qu
  • 不要盲目的在项目中使用LESS CSS dcj3sjt126com Webless
    　如果你还不知道LESS CSS是什么东西，可以看一下这篇文章，是我一朋友写给新人看的《CSS——LESS》 　　不可否认，LESS CSS是个强大的工具，它弥补了css没有变量、无法运算等一些“先天缺陷”，但它似乎给我一种错觉，就是为了功能而实现功能。 　　比如它的引用功能 ? .rounded_corners{     
  • [入门]更上一层楼 dcj3sjt126com PHPyii2
    更上一层楼 通篇阅读完整个“入门”部分，你就完成了一个完整 Yii 应用的创建。在此过程中你学到了如何实现一些常用功能，例如通过 HTML 表单从用户那获取数据，从数据库中获取数据并以分页形式显示。你还学到了如何通过 Gii 去自动生成代码。使用 Gii 生成代码把 Web 开发中多数繁杂的过程转化为仅仅填写几个表单就行。 本章将介绍一些有助于更好使用 Yii 的资源：
  • Apache HttpClient使用详解 eksliang httpclienthttp协议
    Http协议的重要性相信不用我多说了，HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性（具体区别，日后我们再讨论），它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性。因此熟练掌握HttpClient是很重要的必修内容，掌握HttpClient后，相信对于Http协议的了解会
  • zxing二维码扫描功能 gundumw100 androidzxing
    经常要用到二维码扫描功能 现给出示例代码 import com.google.zxing.WriterException; import com.zxing.activity.CaptureActivity; import com.zxing.encoding.EncodingHandler; import android.app.Activity; import an
  • 纯HTML+CSS带说明的黄色导航菜单 ini htmlWebhtml5csshovertree
    HoverTree带说明的CSS菜单:纯HTML+CSS结构链接带说明的黄色导航   在线体验效果：http://hovertree.com/texiao/css/1.htm代码如下,保存到HTML文件可以看到效果：   <!DOCTYPE html > <html > <head> <title>HoverTree
  • fastjson初始化对性能的影响 kane_xie fastjson序列化
    之前在项目中序列化是用thrift，性能一般，而且需要用编译器生成新的类，在序列化和反序列化的时候感觉很繁琐，因此想转到json阵营。对比了jackson，gson等框架之后，决定用fastjson，为什么呢，因为看名字感觉很快。。。   网上的说法：   fastjson 是一个性能很好的 Java 语言实现的 JSON 解析器和生成器，来自阿里巴巴的工程师开发。
  • 基于Mybatis封装的增删改查实现通用自动化sql mengqingyu DAO
    1.基于map或javaBean的增删改查可实现不写dao接口和实现类以及xml，有效的提高开发速度。 2.支持自定义注解包括主键生成、列重复验证、列名、表名等 3.支持批量插入、批量更新、批量删除 <bean id="dynamicSqlSessionTemplate" class="com.mqy.mybatis.support.Dynamic
  • js控制input输入框的方法封装(数字，中文，字母，浮点数等) qifeifei javascript js
    在项目开发的时候，经常有一些输入框，控制输入的格式，而不是等输入好了再去检查格式，格式错了就报错，体验不好。 /** 数字，中文，字母,浮点数(+/-/.) 类型输入限制，只要在input标签上加上 jInput="number,chinese,alphabet,floating" 备注：floating属性只能单独用*/     funct
  • java 计时器应用 tangqi609567707 javatimer
    mport java.util.TimerTask;   import java.util.Calendar;   public class MyTask extends TimerTask {        private static final int
  • erlang输出调用栈信息 wudixiaotie erlang
    在erlang otp的开发中，如果调用第三方的应用，会有有些错误会不打印栈信息，因为有可能第三方应用会catch然后输出自己的错误信息，所以对排查bug有很大的阻碍，这样就要求我们自己打印调用的栈信息。用这个函数：erlang:process_display (self (), backtrace).需要注意这个函数只会输出到标准错误输出。 也可以用这个函数：erlang:get_s
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他