JAVA语言程序设计基础

第一章：JAVA入门基础–开山篇

视频：https://edu.csdn.net/course/detail/8034

前言：什么是java

• 是咖啡飘香的清晨
• 是斯坦福校园意浓情深
• 是James的思想睿智
• 是剁手党双十一挥舞的利刃
• 是大数据服务的平台
• 是春运时节那期盼回家的眼神
• 是ATM机吐出的钞票
• 是Android手机运行的灵魂
• java我的神

本门课程的目标：

掌握JAVA基础语法格式和面向对象编程的基本思想和技能。

JAVA基础课程的思维导图：

一.知识点

1.1：JAVA简介

1.2：JAVA特性

1.3：关键术语（JVM、JRE、JDK）

二.重点：

2.1 术语理解

2.2 JDK环境配置

三.内容

3.1 JAVA的江湖地位：

相当于河南省的少林寺：

语言排行

提问：请问JAVA之父是？？？

James Bond 高司令

James Gosling

James Simons

3.2 历史：

1995年5月23日，Java语言诞生;
1996年1月，第一个JDK-JDK1.0诞生;
1996年4月，10个最主要的操作系统供应商申明将在其产品中嵌入Java技术;
1996年9月，约8.3万个网页应用了Java技术来制作;JAVA和JAVASCRIPT 有多少关系？？？
1997年2月18日，JDK1.1发布;
1997年4月2日，JavaOne会议召开，参与者逾一万人，创当时全球同类会议纪录;
1997年9月，JavaDeveloperConnection社区成员超过十万;
1998年2月，JDK1.1被下载超过2,000,000次;
1998年12月8日，Java 2企业平台J2EE发布;
1999年6月，SUN公司发布Java三个版本：标准版（J2SE）、企业版（J2EE）和微型版（J2ME）;
微软抄袭过SUN公司的JAVA，J#,微软不能使用J开头的语言了，并且赔了很多$。
–>C#

2000年5月8日，JDK1.3发布;

2000年5月29日，JDK1.4发布;

2001年9月24日，J2EE1.3发布;

2002年2月26日，J2SE1.4发布，此后Java的计算能力有了大幅提升;

2004年9月30日，J2SE1.5发布，成为Java语言发展史上的又一里程碑。为了表示该版本的重要性，J2SE1.5更名为Java SE 5.0;这吸收了很多C#的语法格式。

2005年6月，JavaOne大会召开，SUN公司公开Java SE 6。此时，Java的各种版本已经更名，以取消其中的数字“2”：J2EE更名为Java EE，J2SE更名为Java SE，J2ME更名为Java ME;

2006年12月，SUN公司发布JRE6.0;

2009年4月20日，甲骨文以74亿美元的价格收购SUN公司，取得java的版权，业界传闻说这对Java程序员是个坏消息（其实恰恰相反）;

2011年7月28日，甲骨文发布Java SE 7;

2014年3月18日，甲骨文发表Java SE 8;

2017年7月，甲骨文发表Java SE 9;

2018年3月21日，甲骨文发表Java SE 10;

2018年9月25日，甲骨文发表Java SE 11;

2019年3月，甲骨文将发表Java SE 12
———————————————————————————————

还继承了SUN的法务团队，就是律师团，继续打公司，对象已经变了，对象是Google。

3.3 JAVA特点

3.3.1 JAVASCRIPT:弱类型语言，不能编译，网页解释执行，出错了，不好找错！

JAVA语言：强类型，出错的时候，首先编译器搞一下（搞：检查）。

越强越规范，法律越健全，社会越规范。

3.3.2 易学 资料很多

3.3.4 安全性

3.3.4 健壮性

3.3.5 分布式

3.4 应用范围

3.4.1 某宝 某东 某荣耀 某鸡 某盟等等

3.4.2 XXX医院 、银行、教育、12306（）

3.4.3 高并发、分布式 很多；

3.4.4 大数据领域 HADOOP 等就是JAVA写的。

3.4.5 Android平台

3.5核心机制

3.5.1 跨平台

现在聊PC Windows端QQ、 手机安卓上也有QQ、IOS QQ LinuxQQ在QQ上可以互相聊天。

微软：语言：其中一点就是不能跨平台；

3.5.2GC(垃圾回收)

C# ： Object obj=new Object();

C++:Object obj=new Object(); 写完代码之后，都需要销毁一下obj,程序员自己来销毁自己创建的对象。obj.析构函数销毁。

程序员如果忘记了销毁，会导致 内存溢出。

垃圾回收：自动回收机制；

​ java里面有一个垃圾回收器，相当于我们的保洁小姐姐一样，当她发现，这个内存空间的资源没人利用的时候，她就开始进行回收，这样就会让内存得到最大化的利用。非常棒的一个机制。

1day	资源回收	机制：时间片机制；相当于纪检部一直在转圈检查；

3.6 JRE JVM JDK

JVM：java程序语言，运行在java 虚拟机上。(Java Virtual Machine)，对于程序设计语言来说，XXX公司要开发手机版的语言、Linux班的语言、Windows版的语言，还包括了这些语言每一年的更新，因为在不同的平台上，这些语言的语法、格式、适应环境都不同，这样对于语言公司（ORACLE），压力很大，对于程序员来说，压力也很大。有没有一些简便的方式，对于程序员来说，我只搞java，不用你运行在什么平台上。这时候高司令，他们就搞了个java 虚拟机的概念，所有在java虚拟机上的java语言格式都一样，程序员只用搞好你的java程序即可，针对的是java虚拟机。这个语言公司，只用开发若干个不同版本jvm虚拟机即可，大大的节省了程序员的精力和时间。这只是一点，jvm还有很多不错的特性。

JRE:JAVA 运行环境；JVM还有类库，之前NOKIA手机上有一些游戏，贪吃蛇、赛车等java环境的游戏，要跑这些就需要JRE。

​ 是不是相当于我们的游戏环境。

JDK： Java Development Kit -》 JAVA 开发工具包;就是我们要开发一个java游戏，需要JDK，因为大家都是做java程序开发的，所以，咱需要用JDK。

3.7下载安装：

建议：安装路径不要有中文或者特殊符号如空格等。

3.8 配置环境变量

​ 3.8.1 我的电脑–》右键属性—>高级,增加用户变量或者系统变量，二者选一即可。

​ 3.8.2 选择path，进行编辑

​ 3.8.3 path编辑里面，新建一个值

3.8.4填入%JAVA_HOME%bin

​ 3.8.5 进到黑屏程序（使用输入cmd方式）

3.9基本语法格式

3.9.1 java的第一个Helloworld语法格式：

class 类名{

​ public static void main(String[]args){

​ System.out.println(“test”);

​ }
}

今天老师的路径：

d:aaajavabase

javac -encoding UTF-8 XX.java 编译下来会形成字节码文件，可以在jvm上运行。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TKptQOaI-1672666155043)(E:政通路课堂笔记S2J2SE Baseassets/java 3步.jpg)]

编译命令：javac XXX.java

运行命令：java 类名

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-djRJGBrY-1672666155044)(E:政通路课堂笔记S2J2SE Baseassets1575616000209.png)]

任何编译型的语言都有编译器，最终执行程序，都会有结果。

编译型语言： 安倍晋山 日语 字典 写个小纸条；

解释型语言：安倍晋山 翻译官（即时翻译）

3.9.2 注意事项

参考代码1：

//class 关键字,Demo01 类名
class Demo01
{   //左花括号：类定义代码的开始
  //public公共的；static:静态的；void:没有返回类型的;
  //main:主要的方法；相当于学校的大门;
  //参数是一个字符串类型的数组args,相当于要进入大门的一些人或物;
   public static void main(String[]args)
   {
	//系统.输出.打印(内容)
	System.out.println("demo01");
	System.out.println("ByTeachZhang");
   }	
  
}   //右花括号：类定义代码的结束;

参考代码2：

//这时候老师加了个public
public class HelloSchool
{
   public static void main(String[]args){
	System.out.print("Henan");
	System.out.print("ZhengZhou");
  }
}

总结：二者的区别

• 当class前面加public的时候，类名要和文件名一致

• println是输出并换行；print是只输出不换行。

• 第一个案例的格式是ANSI，第二个案例的格式是UTF-8，编译的时候，第一个格式是javac Demo01.java,第二个格式是javac -encoding UTF-8 HelloSchool.java

3.10集成开发工具

IDEA:JetBrains ,IDEA 全称 IntelliJ IDEA，是java编程语言开发的集成环境。IntelliJ在业界被公认为最好的java开发工具，尤其在智能代码助手、代码自动提示、重构、J2EE支持、各类版本工具(git、svn等)、JUnit、CVS整合、代码分析、 创新的GUI设计等方面的功能可以说是超常的。IDEA是JetBrains公司的产品，这家公司总部位于捷克共和国的首都布拉格，开发人员以严谨著称的东欧程序员为主。它的旗舰版本还支持HTML，CSS，PHP，MySQL，Python等。

MyEclipse: 在eclipse 基础上加上自己的插件开发而成的功能强大的企业级集成开发环境，主要用于Java、Java EE以及移动应用的开发。MyEclipse的功能非常强大，支持也十分广泛，尤其是对各种开源产品的支持相当不错。

IDEA安装好之后的一个启动界面


下面这个看一下即可：

3.11 语法总结

class 类名

{ //块定义的开始

//一个类只能有一个静态的main方法

​ public static void main(String[]args)

{方法块定义的开始

​ } //方法块定义的结束

} //块定义的结束;

当行注释： //

多行注释： /*这个是注释 */

文档注释：/** 注释 */

四.作业

4.1 课后作业 VeryEasy

4.2 IDE的熟悉了解

问题：一直出现

把Build Automatically 前的对勾去掉,再试验会发现流畅多了。

4.3 java：编译解释型语言；跨平台

4.4环境变量

• JAVA_HOME 大写、下划线 jdk的安装路径，没有bin

第二章：数据类型、变量和运算符

经典面试题

JAVA有几种数据类型？

​ 引用数据类型和基本数据类型入手

​ 再说基本数据类型的四类八个

一.知识点

1.变量、标识符、运算符

2.数据类型

3.输入和输出

二.重点

​ 重点就是掌握JAVA的语法格式，运算符、标识符的使用、数据类型的使用、输入输出的使用

三.内容

3.1关键字

关键字	含义
abstract	表明类或者成员方法具有抽象属性
assert	断言，用来进行程序调试
boolean	基本数据类型之一，布尔类型
break	提前跳出一个块
byte	基本数据类型之一，字节类型
case	用在switch语句之中，表示其中的一个分支
catch	用在异常处理中，用来捕捉异常
char	基本数据类型之一，字符类型
class	声明一个类
const	保留关键字，没有具体含义
continue	回到一个块的开始处
default	默认，例如，用在switch语句中，表明一个默认的分支
do	用在do-while循环结构中
double	基本数据类型之一，双精度浮点数类型
else	用在条件语句中，表明当条件不成立时的分支
enum	枚举
extends	表明一个类型是另一个类型的子类型，这里常见的类型有类和接口
final	用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量
finally	用于处理异常情况，用来声明一个基本肯定会被执行到的语句块
float	基本数据类型之一，单精度浮点数类型
for	一种循环结构的引导词
goto	保留关键字，没有具体含义
if	条件语句的引导词
implements	表明一个类实现了给定的接口
import	表明要访问指定的类或包
instanceof	用来测试一个对象是否是指定类型的实例对象
int	基本数据类型之一，整数类型
interface	接口
long	基本数据类型之一，长整数类型
native	用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
new	用来创建新实例对象
package	包
private	一种访问控制方式：私用模式
protected	一种访问控制方式：保护模式
public	一种访问控制方式：共用模式
return	从成员方法中返回数据
short	基本数据类型之一,短整数类型
static	表明具有静态属性
strictfp	用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范 [1]
super	表明当前对象的父类型的引用或者父类型的构造方法
switch	分支语句结构的引导词
synchronized	表明一段代码需要同步执行
this	指向当前实例对象的引用
throw	抛出一个异常
throws	声明在当前定义的成员方法中所有需要抛出的异常
transient	声明不用序列化的成员域
try	尝试一个可能抛出异常的程序块
void	声明当前成员方法没有返回值
volatile	表明两个或者多个变量必须同步地发生变化
while	用在循环结构中

变量和标识符规则：驼峰命名法

变量：变量类似于数学中的未知数；

存储的是哪些东西？？？代表什么意思呢？

指令：临时的变量；变：可变的量；

2.1.1 规则

• 由字母、$、下划线组成（首字母能不能是数字？？）

• 数字不可以打头

• 不可以使用关键字

• 区分大小写

• 标识符不能包含空格

• 注：尽量”见名知意“，变量名有意义；

  驼峰命名法：

  **第一个单词以小写字母开始；从第二个单词开始以后的每个单词的首字母都采用大写字母，**例如：myFirstName、myLastName，这样的变量名看上去就像骆驼峰一样此起彼伏，故得名。

  测试一下：
  int 8nianling;对不？
  String +myName;
  double int;//int 变量名对不？
  String myName、myname;
  

  名称命名规范：

• 包名:多个单词组成的包名，字母都小写

• 类名、接口名：首字母大写，类名尽量名词；

• 方法名：驼峰命名法；尽量动词；getName()

• 常量名：所有字母大写；多个单词用_线隔开。

2.2数据类型

float:3.402E+38F; 3.402*10的38次幂（方）

class TypeDemo 
{
	public static void main(String[] args) 
	{
		//1.字符型：关键字char,一般用来指性别等单个字符的变量
		char gender='男'; //java里面这个变量需要给它赋值后再使用;
		System.out.println(gender);
		//char和int互相转化；num是一个字符型,输出的时候一定是字符
		char num='a';  //num=97
		//a这个字符对应的计算机里面的编码就是97
		System.out.println(num);
		//2.boolean型
		//boolean flag=2>1; //2>1:true;如果判断相等，能不能用=号呢？
		//java：a=2;表示赋值把2赋值给a；a==2;表示判断a是否和2相等;
		boolean flag=2==1;
		System.out.println(flag);
		//3.浮点型;
		double height=1.80;
		System.out.println("身高是："+height);
		//*注意：系统默认的是double类型，75.2->float;double->float;
		//如何使用呢？在数据类型后面加f
		float weight=75.2f;
		System.out.println("体重是:"+weight);
		//4.整型；4个；如何记忆，从小到大；byte short int long
		//占用的空间：1个字节  2个字节 4个字节 8个字节
		//提问：为啥不是0-255呢？规定只是说了一点，更重要的是：
		//计算机里面考虑了符号的问题；-128-+127
		byte num1=-128;
		System.out.println(num1);
		int age=222;
		System.out.println(age);
		long num3=88888888;
		System.out.println(num3);
		//今天我们讲了基本数据类型的4类8个；都要使用以下;
		int a='a';
		System.out.println(a);
		//第36行代码a应该输出的是啥？？？97 为什么？？？
	}
}	

2.3运算符

2.3.1赋值运算符

单等号：=

语法格式：数据类型 变量名=变量初值；

int age=18;

double height;

height=1.81;

int num1=22,num2=88;多个变量赋值

2.3.2 算术运算符

3%9==3

9%3==0

2.3.3关系运算符

== != >= <= < >

2.3.4逻辑运算符

​ &&:逻辑与运算 相当于物理里面的串联电路

​ ||:逻辑或运算 相当于物理里面的并联电路

​ !:逻辑非运算

2.3.5 条件运算符(三元运算符)

元：元素,三个元素

条件表达式?语句1:语句2

		int a=4,b=5; //a>b==>true
//		System.out.println(a>b?"结果1":"结果2");
		int result=a>b?a++:a--;
		System.out.println(result);
		//结果=a++; 先赋值,再运算(++)
		// 结果=++a
//		System.out.println(a>b?++a:--a);

2.3.6 运算符优先级表

优先级	运算符	结合性
1	()、[]、{}	从左向右
2	!、+、-、~、++、–	从右向左
3	*、/、%	从左向右
4	+、-	从左向右
5	«、»、>>>	从左向右
6	<、<=、>、>=、instanceof	从左向右
7	==、!=	从左向右
8	&	从左向右
9	^	从左向右
10	|	从左向右
11	&&	从左向右
12	||	从左向右
13	?:	从右向左
14	=、+=、-=、*=、/=、&=、|=、^=、~=、«=、»=、>>>=	从右向左

2.4输入（Scanner）

Scanner类:扫描仪 ,是一个输入设备

next():接受的是一个字符串

nextInt():接受整型数字

nextDouble():接受double类型浮点数

//输入类;参数：System.in输入流;
		Scanner input=new Scanner(System.in);
		System.out.println("请输入您的姓名：");
		String name=input.next();
		System.out.println("请输入您的年龄:");
		int age=input.nextInt();
		System.out.println(name+":"+age);
		System.out.println("请输入身高:");//float
		float height=Float.parseFloat(input.next());  //字符串转Int ;Integer.parseInt(字符串)
		System.out.println("身高:"+height);
		//Integer,Float:这些是int,float的包装类型;

//老师的类名是不是首字母大写，一定要这样符合java的命令规范.
import java.util.Scanner;
class ScannerDemo 
{
	public static void main(String[] args) 
	{
		//Scanner类,输入类;C#:namespace
		//using MySql.SqlConnection;
		//java下面的概念不叫命名空间，叫包;
		//如果用到Scanner类，需要导入这个类所在的包
		//Scanner是引用数据类型，注意看new了，去内存new了分配空间
		Scanner input=new Scanner(System.in);
		System.out.println("请输入用户名:");
		String name=input.next();
		System.out.println("用户："+name);//+这时候的作用是连接作用
		System.out.println("请输入年龄：");
		int age=input.nextInt();
		System.out.println("年龄："+age);
		//小作业：Scanner实现 两个数字的加减乘除求余操作;
		//类型转换，大的数据类型转小的数据类型;
		//Integer.parseInt(字符串)->字符串转int类型;
		//格式：目标数据类型 变量=(目标数据类型)值;
		System.out.println("请输入一个小数:");
		int result=(int)input.nextDouble();
		System.out.println(result);
	}
}

四.作业

4.1 JamesBond加密

4.2 定义两个变量，一个变量存储“007间谍”，一个变量存储字符串“詹姆斯.邦德”，现在请你写一个程序，交换二者的值。

​ 我们称之这种方式为交换算法。

第三章：分支控制语句

一.知识点

1.1 if分支结构

1.2 switch分支结构

二.重点

2.1 理解分支结构

三.内容

3.1 流程控制结构：顺序、分支、循环

if：如果的意思

3.2 if语句,分四类

3.2.1 单if语法：

if(表达式为true){ 条件表达式返回的值是布尔类型的（true/false)

​ 执行的代码

}

应用场景：用户选择，输入‘Y’继续；

流程图：char choice=Scanner接受一下

if(chooice和Y’进行值的比较判断)

import java.util.Scanner; //需要导入java.util包
class IfOne 
{
	public static void main(String[] args) 
	{
		//1.if的第一种使用方式;
		//boolean flag=5>4;
		//System.out.println(flag);
		//定义了一个Scanner的对象(变量)input
		//并且给它初始化（引用类型，需要new)
		Scanner input=new Scanner(System.in);
		System.out.println("请输入您是否进入到王者农药游戏...");
		String choice=input.next();//next()接受字符串
		System.out.println("测试输出"+choice);
		//针对字符串的等值判断，不能用==号，用equals进行比较
		//==号做等值判断，仅仅使用于基本数据类型
		//==号在引用数据类型判断，判断的是引用数据类型的
		//地址是否相同;
		if("Y".equals(choice)){
			System.out.println("您选择进入到游戏...");
		}
	}
}

3.2.2 if else语法：else:其他

两个条件，真 假判断

分支：有多个选择，如果条件为真的时候，一种选择；其他的时候又是一种选择。

if(条件表达式为true){

​ //true的代码

}else{

​ //false的代码

}

应用场景：用户选择，输入‘Y’继续；输入N(或不输入)退出

流程图：

3.2.3 if elseif else语法：

超过2个条件的分支，多条件分支语句

if(条件表达式1为true){

​ 代码段1

}else if(条件表达式2为true){

​ 代码段2

}else if(条件n为true){

​ 代码段n,此处省略若干个条件

}

else{

​ 前台代码

}

应用场景：

我想买车，买什么车决定于我在银行有多少存款

如果我的存款超过500万，我就买凯迪拉克

否则，如果我的存款超过100万，我就买帕萨特

否则 如果我的存款超过50万，我就买依兰特

否则， 如果我的存款超过10万，我就买奥托

否则， 如果我的存款10万以下 ，我买捷安特

流程图：

import java.util.Scanner;//导包
class IfTwo 
{
	public static void main(String[] args) 
	{
		//3.有多个条件的分支语句
		System.out.println("请输入您的存款，利于评估购车");
		Scanner input=new Scanner(System.in);
		//需要定义一个变量来接受用户的存款;
		double money=input.nextDouble();
		if(money>500){
			System.out.println("可以买个法拉驴");
		}else if(money>100){
			System.out.println("法拉第四...");
		}else if(money>50){
			System.out.println("可以买个宝骏...");
		}else if(money>10){
			System.out.println("可以买个长城H6");
		}else{
			System.out.println("可以买个超级环保的OFO");
		}
	}
}

​ 提升智商：这种多条件的判断，先判断条件1，再判断条件2，再判断条件3，再判断条件4，最后else。如果这里面有100000个客户，让你写代码，你还这样写好吗？

​ 赠送答案和思路

class IQQuestion
{
	public static void main(String[] args) 
	{
		//只写思路;访问频率最高的一定在最前面
		if(money>=50 && money<=100){  //60%
			//中端客户的代码判断
		}else if(money<=10){
			//低端客户代码判断
		}else{
			//高端客户代码
		}
	}
}

3.2.4 嵌套if语句

if(条件表达式为true){

​ if else语句

}else{

​ if 语句

}

应用场景：

学校举行运动会，根据性别分别进入男子组和女子组，百米赛跑跑入15秒内的学生有资格进决赛

我国的田径记录是女子100米是10.79，是李雪梅在上海第八届全国运动会创造的成绩，男子100米田径记录是9.91，单位是啥？

就像足球一样，男足和女足，就不一样，男足对抗更激烈。

流程图：

import java.util.Scanner;
class IfThree 
{
	public static void main(String[] args) 
	{
		//1.嵌套的if分支语句 
		System.out.println("请输入参赛选手的性别：");
		Scanner input=new Scanner(System.in);
		String gender=input.next();
		System.out.println("请输入选手的成绩：");
		double score=input.nextDouble();
		//根据性别进行判断;
		if("男".equals(gender)){
			System.out.println("进入男子组比赛");
			if(score<9.1){
				System.out.println("进入到决赛");
			}else{
				System.out.println("淘汰出局");
			}

		}else{
			System.out.println("进入女子组比赛");
			if(score<10.5){
				System.out.println("进入到决赛");
			}else{
				System.out.println("淘汰出局");
			}
		}
	}
}

3.3 switch结构

英文：开关

应用场景：

小芳为她儿子的小天才电话手表设定了自动拨号

按1：拨爸爸的号

按2：拨妈妈的号

按3：拨爷爷的号

按4：拨奶奶的号

流程图：

总结：switch结构用于固定值的时候更多；判断月份、季节；权限（1 2 3 4）；

			case "貂蝉":
				System.out.println("刺客，近战无敌..");
				break;
			case "昭君":
				System.out.println("刺客，近战无敌..");
				break;
			case "玉环":
				System.out.println("刺客，近战无敌..");
				break;

//当多个常量值，输出一样的时候，可以合并到一起;

//当多个常量值，输出一样的时候，可以合并到一起;
			case "貂蝉":				
			case "昭君":				
			case "玉环":
				System.out.println("刺客，近战无敌..");
				break;

if 语句：用于固定值或某个范围的时候;范围的时候更多使用if语句；

总之，if语句使用更广泛。

当二者嵌套的时候，一般是if嵌套switch语句，但是有时候，swtich就要嵌套if分支语句，建议大家写一个方法，在需要嵌套if语句的时候，来调用这个方法即可。

四.作业

4.1 根据客户的消费金额，完善会员折扣作业,使用if语，也可以使用switch语句做下：

第四章：循环语句

一.知识点

1.1 while循环

1.2 do while循环

1.3 for循环

二.重点

2.1掌握三类循环，最起码掌握两类

2.2固定次数循环和非固定次数循环区别

三.内容

3.1 while循环;

应用场景：

小锐锐同学Java考试成绩未达到自己的目标。为了表明自己勤奋学习的决心，他决定写一百遍“我一定能学会JAVA”。

流程图：

编码规范：缩进和换行

class WhileOne 
{
	public static void main(String[] args) 
	{
		//1.while循环;步骤
		//1.1 定义变量
		//1.2 while(条件判断)
		//1.2 循环体
		//1.3 变量的自增/自减 
		int num=1;
		while(num<=100){
			System.out.println("我要好好学习JAVA,练了"+num+"遍");
			num++; //计数器,像跑圈，统计圈数
		}
	}
}

案例：

要开始考试了，请你打印50分试卷，理解流程图；

3.2 do while循环

语法格式：

do{

​ 循环体代码

​ 变量自增/自减

}while(条件)

刚才第一个代码的仿照

class DoWhileOne 
{
	public static void main(String[] args) 
	{
		//1.定义变量
		//2.do{} 循环体
		//3.while(条件判断)
		int num=1;
		do{
			System.out.println("练习宝典"+num+"遍");
			num++;
		}while(num<=100);
	}
}

应用场景：

经过几天的学习，老师给小锐锐一道测试题，让他先上机编写程序完成，然后老师检查是否合格Y。如果不合格N，则继续编写。……不固定次数的循环；

import java.util.Scanner;  //导包
class DoWhileTwo 
{
	public static void main(String[] args) 
	{
		//1.不固定次数的循环，需要用户自行输入值
		//1.定义变量,定义输出提示变量sc，并且让用户输入
		String result;				
		Scanner sc=new Scanner(System.in);
		//2.do while;字符串用的是equals(值)判断
		do{
			System.out.println("欧在使劲练习java...");
			System.out.println("老师满意吗？");
			result=sc.next();
		}while("N".equals(result));
		System.out.println("老师很满意恭喜通关!");
	}
}

do while/while循环的区别：

do while:最少至少一次；

while:必须先判断条件符合，才能执行;

3.3 for循环

应用场景：+1

for循环的重点：是语法格式：

顺序： 1 2 3 4;2 3 4 ;2 3 4;

3.4 无限循环格式及其不固定次数循环

总结：固定次数循环使用for循环格式比较好；

不固定次数的循环，使用while 或do while循环;

while(true){

​ 代码

}

for(;????{

​ 代码

}

//		while(true){
//			System.out.println("我爱Java");
//		}
		for(;;){
			//加条件；然后break;就退出了.
			System.out.println("我们要上火星了");
		}
		//这两个无限循环格式；

3.5 break continue

break:退出循环本身; 相当于比赛车坏了，直接退出比赛

continue:退出本次循环，继续下一次循环； 相当于车胎爆了，换了车胎继续

四.作业

4.1案例：求学生5门课的平均成绩；

import java.util.Scanner;//导包
class AvgDemo 
{
	public static void main(String[] args) 
	{
		//求学生5门课的平均成绩,使用三种循环都可以;
		//1.定义变量;总成绩，输入对象变量sc
		double sum=0.0;
		Scanner sc=new Scanner(System.in);
		//2.利用for求5门课的总成绩;1 2 3 4 5
		for(int i=1;i<=5;i++){
			System.out.println("请输入第"+i+"课的成绩：");
			double score=sc.nextDouble();
			//sum=第一次的成绩+第二次的成绩+第3次+第4次+第五次;
			//score接受第1 2 3 4 5的成绩
			sum=sum+score;
		}
		System.out.println("平均成绩为："+sum/5);
	}
}

4.2 用户名和密码登录验证最多输入3次；假设用户：admin;密码；123aaa;等待用户输入用户名和密码；

package chapter03;

import java.util.Scanner;
public class LoginCheck {

	public static void main(String[] args) {
		//1.声明变量;
		int i;
		String name,pwd;
		Scanner input=new Scanner(System.in);
		//2.判断;最多输入3次;
		for(i=1;i<=3;i++){
			//用户输入;
			System.out.print("请输入用户名：");
			name=input.next();
			System.out.println("请输入密码:");
			pwd=input.next();
			//嵌套一个if，对或者错;
			if("admin".equals(name)&&"123aaa".equals(pwd)){
				System.out.println("用户名和密码正确！欢迎登陆！");
				break;//只要正确了，就退出循环;
			}else{
				System.out.println("用户名和密码错误！还有"+(3-i)+"次机会");
				continue;//结束本次循环，继续下一次循环;
			}
		}
		if(i==4){
			System.out.println("您输入次数超过3次，登陆失败!");
		}
	}
}

第五章：数组

一.知识点

1.1.数组的定义

1.2.数组的访问

1.3.数组的排序

1.4二维数组

二.重点

2.1.重点的使用

2.2.重点的方法

2.3.数组的扩展

三.内容

3.1.数组的概念？为什么使用数组？

问题：

Java考试结束后，老师给小锐锐分配了一项任务，让他计算全班（37人）的平均分？如何办？

输出每个人的成绩，以及将来要存储每个人的成绩。

上次写的循环，是定义一个临时的变量，接受完毕之后就不管了，后面的把前面的给覆盖掉了。

发扬愚公移山的精神，定义39个变量：score1,score2,…,score37, sum,avg; 39

我们在这里定义变量，会花费大量的时间，将来写程序还要记忆这些变量，问题就是太费事儿。

假设现在让你统计来郑州的人员，没人的体温，来了5000万个人，“愚公移山”精神，定义5000万个变量。

同学们，我问你定义5000万了变量，需要花费多少时间，先不查最高体温，最近7天体温。

经过同学们的回答，发现太耗时了，也太不方便。

C# mysql ajax javaweb

概念：

数：数据的意思，包括数（正数、负数、0、小数）、字符串、布尔型、其他引用类型等等等。

组：分组，一个小组>=0,一组；

数组：一组相同数据类型的集合。

语法：

之前定义变量：

数据类型 变量名=值；

数据类型 [] 数组名=赋值；//数组名前面有个[]

3.2.使用数组的步骤：

int age;double height;char c;有没有new；

int[]arr; //多了个[];–>list在编程语言里面，一般都是集合。

arr=new int[5]; //new是个啥啥？？？

arr[0]=8; //0:数组的下标；

处理：arr[0]*10;

import java.util.Scanner;

public class ArrayDemo {

	public static void main(String[] args) {
		String[]longmen=new String[5];//1.声明，定义长度为5的字符串类型的数组;
		Scanner input=new Scanner(System.in);
		//longmen={"","","","",""};大家试验;
		//数组名[下标]=值;注意：数组下标从0开始；最大值：长度-1；
//		longmen[0]="郝明超";
//		longmen[1]="方一帆";
//		longmen[2]="左恩光";
//		longmen[3]="小锐锐";
//		longmen[4]="赵美丽"; //数组最大值是4；
//		longmen[5]="张老师"; //写代码的时候没有错，运行的时候出错；数组越界异常；
		for(int i=0;i<5;i++){  //2.输入
			System.out.println("请输入第"+(i+1)+"位客户的名称：");
			longmen[i]=input.next();
		}
		//3.遍历;
//		for(int i=0;i<5;i++){
//			System.out.println(longmen[i]);
//		}
		//for in格式：数组类型 变量名 : 数组（或集合）
		for(String name:longmen){
			System.out.println(name);
		}
	}
}

3.3 length属性、for ：、{}赋值

length:表示数组的长度

for : 针对数组元素进行遍历

{}:针对数组进行直接赋值

class ArrayThree 
{
	public static void main(String[] args) 
	{
		//还是定义一个字符串类型的数组;
		//使用{}给数组赋值的时候，前面不需要new之类的格式
		//它是数组名={值1,...值n},直接赋值格式.
		//String[]names={"杰克.马","Pony.马","冬梅.马"};
		int[]names={11,12,18,19};
		//System.out.println(names.length);
		//格式：表示变量依次从数组里面取值
		//for(数组数据类型 变量 :数组名){}
		for(int name:names){
			System.out.println(name);
		}
	}
}

3.4内存结构

3.5 二维数组

一维数组：

int[]arr;假如说arr本身又是数组咋办？

class TwoArray 
{
	public static void main(String[] args) 
	{
		//二维数组;3行5列;
		int[][]twoArray=new int[3][5];
		//二维数组的长度指的是它的行数;
		//System.out.println(twoArray.length);
		//如何给二维数组赋值;先搞定第一行;
		twoArray[0][0]=1;
		twoArray[0][1]=2;
		twoArray[0][2]=3;
		twoArray[0][3]=4;
		twoArray[0][4]=5;
		//如何给二维数组赋值;再搞定第二行;
		twoArray[1][0]=2;
		twoArray[1][1]=4;
		twoArray[1][2]=6;
		twoArray[1][3]=8;
		twoArray[1][4]=10;
		//如何给二维数组赋值;再搞定第三行;
		twoArray[2][0]=3;
		twoArray[2][1]=6;
		twoArray[2][2]=9;
		twoArray[2][3]=12;
		twoArray[2][4]=15;
		//循环输出;不同的是行数不同;
		for(int j=0;j<5;j++){
			System.out.println(twoArray[0][j]);
		}
		for(int j=0;j<5;j++){
			System.out.println(twoArray[1][j]);
		}
		for(int j=0;j<5;j++){
			System.out.println(twoArray[2][j]);
		}
	}
}

class TwoArray2 
{
	public static void main(String[] args) 
	{
		int[][]twoArray={
					{1,2,3,4,5},
					{11,22,33,44,55},
					{111,222,333,444,555}
				};
		//先简化下面的代码
		for(int i=0;i<3;i++){
			//把刚才重复的代码拷贝过来
			for(int j=0;j<5;j++){
				System.out.println(twoArray[i][j]);
			}
		}
	}
}

四.作业

4.1

4.2 任意一个人输入年龄，就可以判断出他是哪个年龄段的人？

0-9 儿童
10-19 少年
20-29 青少年
30-39 青年
40-49 壮年
50-59 中年
60-69 中老年
70-79 老年
80-89 老老年
90-99 老老老年

方法一：使用之前的switch或if语句来实现；

方法二：提升数据结构；使用数组这种数据结构;(经典面试题，不让使用if和switch)

//1.定义变量；
		int age;
		Scanner input=new Scanner(System.in);
		//2.输入数据;
		System.out.println("请输入您的年龄:");
		age=input.nextInt();
		//3.业务判断；
		String[]arr={"儿童","少年","青少年","青年","中年","中老年"};
		//4.输出;
		System.out.println("年所处的年龄阶段:"+arr[age/10]);

4.3 课后作业第2题，求30个数的平均值（每5个计算一次）；

//1.声明变量数组a 30,数组b  6
		int[]a=new int[30];
		int[]b=new int[6];
		//2.赋值;
		for(int i=0;i<30;i++){
			a[i]=i*2;
		}
		//2.2输出当前a
		for(int n:a)
			System.out.print(n+"t");
		System.out.println();
		//3.每5个求一下平均值;4 9 14 19；扩充考虑有n个平均值如何做
		for(int i=4;i<30;i+=5){
//			b[0]=a[0]+a[1]+a[2]+a[3]+a[4];
			b[i/5]=(a[i-4]+a[i-3]+a[i-2]+a[i-1]+a[i])/5;
		}
		for(int n:b)
			System.out.print(n+"t");

//动态扩充若干数的平均值;
int[] array = new int[30];
		for (int i = 1; i < 31; i++) {
		    array[i-1] = i*2;
		}
		for (int i : array) {
		    System.out.print(i+",");
		}
		System.out.println();
		int[] b = new int[6];
		int steps = 5;
		int c = 0;
		for (int i = 0; i < array.length; i=i+steps) {
		    int sum = 0;
		    for (int j = i; j <i+steps; j++) {
		        sum=sum+array[j];
		    }
		    System.out.print(sum+",");
		
		    b[c++] = sum/steps;
		}
		System.out.println();
		for (int n:b)
		{
		    System.out.print(n+",");
		}

第六章：常用类

一.知识点

1.1 字符串String类

1.2 StringBuffer类

1.3 日期和日期格式化类

二.重点

2.1 String和StringBuffer的区别

2.2 ==和equals的区别

三.内容

3.1 字符串

​ 首先应该明确它是什么类型？是基本数据类型还是引用数据类型，是引用数据类型。

​ 无处不在的字符串;不是字符，“郑州要开学了”,可以理解是字符数组

概念：是一串字符，不是一个字符。

3.1.1 String类 存储

3.1.2 ==和equals的区别

class StringOne 
{
	public static void main(String[] args) 
	{
		//1.定义变量，并赋值;
		String s1="hello";            //字符串直接赋值
		//只要碰到new，就表示去内存分配空间
		String s2=new String("hello");//引用数据类型直接new
		System.out.println(s1==s2);  //==  比较的是内存的地址；
		//要比较两个字符串s1 s2内容是否一致？
		System.out.println(s1.equals(s2)); //true
		String s3="hello";
		System.out.println("s3 s1内容："+s1.equals(s3));
		System.out.println("s3==s1:"+(s1==s3));
		//s1==s3,返回的地址是一致的，结果true
		//JVM：字符串太常用了，针对直接赋值的形式，先去内存区域
		//查找是否有相同的内容的字符串空间，如果有，则将该内存的
		//地址赋值给当前字符串变量。
	}
}

3.1.3 String类的+和concat

//不可变字符串类  
class StringAppend 
{
	public static void main(String[] args) 
	{
		//测试一下String类的追加;String类：不可变字符串类;
		String s1="hello";
		//String s2=s1+"tea.zhang";	//没有append
		//s1.concat(新字符串):将新串添加到s1末尾
		String s2=s1.concat(".tea.zhang");
		System.out.println(s2);  //hello.tea.zhang
		System.out.println(s1==s2);  
		//+号连接的时候返回值:false
	}
}

//可变字符串类
class StringBufferDemo
{
	public static void main(String[] args) 
	{
		//StringBuffer类：可变字符串类;引用数据类型
		//"hello"是一个字符串，不能直接给StringBuffer类型赋值
		//二者类型不一致;
		//StringBuffer sb=new StringBuffer("hello");
		StringBuffer sb=new StringBuffer();//():不放内容
		sb.append("hello");   //append:追加
		System.out.println(sb);		
		System.out.println(sb==sb.append("tea.zhang"));
		//sb:地址1100；
	}
}

3.1.4 String类常用方法

s1.concat(String s2) 指定字符串s2连接到此字符串的结尾

s1.charAt(索引) 找到索引处的char字符

[]toCharArray() 将此字符串转换为一个新的字符数组

s1.startsWith(字符串2) 返回s1是否以s2开始的字符串,结果为true/false

s1.endsWith(字符串串s2) 返回s1是否以s2结束的字符串,结果为true/false

s1.equals(s2) 判断s1是否与s2字符串的内容一致

equalsIgnoreCase(字符串) 忽略大小写的判断内容是否一致

[]getByts() 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中

int indexOf(字符/字符串) 返回指定字符/字符串在此字符串中第一次出现处的索引

int lastIndexOf(字符/字符串) 返回指定字符/字符串在此字符串中最后一次出现处的索引

isEmpty() 是否为空

length() 返回字符串的长度

replace(old,new) 字符串替换

split(拆分字符) 将字符串按照指定格式拆分

subString（开始位置,结束位置)截取字符串

toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写

toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写

trim() 返回字符串的副本，忽略前导空白和尾部空白

contains() 当且仅当此字符串包含指定的 char 值序列时，返回 true

//忽略大小写？？？
		String name="admin";
		String str;
		System.out.println("请输入用户名：");
		Scanner input=new Scanner(System.in);
		str=input.next();
		//只有你输入的内容是admin的时候，进入
		//equalsIgnoreCase():忽略大小写的方法;
		if("admin".equalsIgnoreCase(str)){
//			str.toUpperCase():转换为大写;str.toLowerCase()
			System.out.println("登录进入");
		}else{
			System.out.println("登录失败");
		}

3.2 StringBuilder类

可变字符串类和不可变字符类效率的比较

class StringVSStringBuffer 
{
	public static void main(String[] args) 
	{
		//比较一下String类和StringBuffer类的效率;
		//利用当前系统毫秒数得到当前的时间
		long startTime=System.currentTimeMillis();
		//System.out.println(startTime);
		String s="hello";
		for(int i=0;i<100000;i++)
			s+=i;    //利用不可变类，创建新的字符串;
		//再次定义一个变量，得到当前系统的时间毫秒数;
		long endTime=System.currentTimeMillis();
		//System.out.println(endTime);
		System.out.println("不可变类耗时:"+(endTime-startTime)+"毫秒");
		//再次测试可变字符串类;
		//StringBuffer sb=new StringBuffer("hello");
		StringBuilder sb=new StringBuilder("hello");
		//测试：Builder类 0毫秒；Buffer类：2毫秒
		//再次得到系统的毫秒数，开始时间;
		startTime=System.currentTimeMillis();
		//中间就是利用循环来测试可变字符串类的效率
		for(int i=0;i<100000;i++){
			sb.append(i);
		}
		//System.out.println(sb);输出测试
		//再次得到结束时间
		endTime=System.currentTimeMillis();
		System.out.println("可变字符串类:"+(endTime-startTime)+"毫秒");
	}
}

​ 一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。 多线程还是用StringBuffer类。

当我们的项目中，如果需要内容频繁更改的时候，使用StringBuffer/StringBuilder类，效率更高。

3.3 日期及其字符串格式化

日期和时间模式	结果
"yyyy.MM.dd G 'at' HH:mm:ss z"	2001.07.04 AD at 12:08:56 PDT
"EEE, MMM d, ''yy"	Wed, Jul 4, '01
"h:mm a"	12:08 PM
"hh 'o''clock' a, zzzz"	12 o'clock PM, Pacific Daylight Time
"K:mm a, z"	0:08 PM, PDT
"yyyyy.MMMMM.dd GGG hh:mm aaa"	02001.July.04 AD 12:08 PM
"EEE, d MMM yyyy HH:mm:ss Z"	Wed, 4 Jul 2001 12:08:56 -0700
"yyMMddHHmmssZ"	010704120856-0700
"yyyy-MM-dd'T'HH:mm:ss.SSSZ"	2001-07-04T12:08:56.235-0700

import java.util.Date;   //记着导包，java.util包;工具包;
//家政服务员，你带工具去服务;
import java.text.SimpleDateFormat;//导包
class  DateDemo
{
	public static void main(String[] args)throws Exception
	{
		//日期时间类;
		Date date=new Date();
		System.out.println(date);
		//输出的是欧洲这种时间格式;
		//转换成我们中文的时间日期格式;
		//利用一个转换类;参数格式：yyyy-mm-dd
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss秒");
		//将给定的 Date 格式化为日期/时间字符串
		//并将结果添加到给定的 String;多个参数的格式是StringBuffer
		//日期时间转换为字符串
		String sb2=sdf.format(date);
		System.out.println(sb2);
		//字符串转换为日期时间格式
		String str="2020年3月24日 10时58分21秒";
		//sdf:日期转换类.parse(时间字符串)
		Date date2=sdf.parse(str);
		//测试已经转换为了系统的日期.
		System.out.println(date2);


	}
}

四.作业

4.1登录时不考虑用户名的大小写问题，实现登录

使用equalsIgnoreCase()方法 使用toLowerCase()方法使用toUpperCase( )方法

4.2 字符串的拆分作业

第七章 类的属性和方法

一.知识点

1.类的概念、对象的定义和使用

2.属性、方法的使用

3.方法的四种类型

二.重点

1.类的定义和使用

2.四类方法

三.内容

面向对象的概念：

​ JAVA是一门面向对象的语言，是纯粹OO的语言。万事万物，皆为对象。现实世界，你的电脑、笔记本、鼠标、键盘、风扇、杯子，都是对象，我们本身也是对象，同样，一些概念的东西也可以称之为对象，比如说天气、湿度、压力、重力等等，在特定场合使用的概念，也可以称之为对象。

​ 有很多的对象，比如说笔记本电脑，有惠普、联想、方正、东芝等等，都是一类，我们成为笔记本电脑，对这些类型相同的对象进行了分类。我们叫笔记本电脑。

3.1 类是什么？

3.1.1 类的概念：

​ 是相同的属性和行为的对象的抽象群体、模板、是一个统称，是一个大的类别。

对象：

​ 是类的一个具体化的实现、是一个实际的案例，实例。

二者联系：

3.1.2类和对象的关系：

​ 类是统称，是抽象化；对象是具体化；

现实：人类、哺乳动物类、狗类、猫类、飞机类、商品类、机器类等等；

对象：张三 旺财 波音某飞机 等等；

分析了一个小案例

3.1.3 定义类

静态特征：属性

动态行为：方法

3.2 定义类的步骤

定义类的时候:

class 类名{

​ //1.静态属性;

​ //2.动态行为

}

public class Car {
	//public:公共的；访问权限修饰符;用来设置类或属性、方法的访问范围；
	//1.属性：静态;public
	public String pinpai="大众甲壳虫";
	public double price;
	public String color;
	public int speedLimit;  //速度限制
	public boolean isSale;//是否卖了
	//2.行为：动态;
	//2.1打印信息;
	public void printInfo(){
		System.out.println("汽车品牌"+pinpai);
		System.out.println("汽车价格："+price);
		System.out.println("汽车颜色："+color);
		System.out.println("汽车速度："+speedLimit);
		System.out.println("汽车是否卖了？："+isSale);
	}
}

public class TestCar {
	public static void main(String[] args) {
		//1.使用声明Car类的对象；叫car
		Car car;
		//2.new一下;在内存里面，分配地址;当new的时候，注：引用类型：默认为null
		//double：0.0;int等：0；也可以在定义的时候，赋值：相当于数据库的默认值;
		car=new Car();
		//3.赋值;对象.属性=值;
		car.pinpai="辉腾";
		car.price=3000000;
		car.speedLimit=60;
		car.color="紫色";
		car.isSale=true;
		//4.测试;		
		car.printInfo();
	}
}

3.2 四类方法：

3.2.1： 无参数、无返回值的方法；void：就是无返回值

public void printInfo(){
		System.out.println("汽车品牌"+pinpai);
		System.out.println("汽车价格："+price);
		System.out.println("汽车颜色："+color);
		System.out.println("汽车速度："+speedLimit);
		System.out.println("汽车是否卖了？："+isSale);
	}

3.2.2: 有参数、无返回值的方法；fillGas(int sheng)

public void fillGas(double sheng){
		System.out.println("汽车加了"+sheng+"升气");
	}

3.2.3: 无参数、有返回的方法；

public String getName(){
		return name;
	}

3.2.4: 有参数、有返回值的方法

public boolean isChao(int speed){
		if(speed<=speedLimit)
			return true;
		else
			return false;
	}

3.3 ：关于方法的总结：

3.3.1 方法只有被调用才会被执行

3.3.2 方法只能调用方法，不能在方法内部定义方法;

方法内存调用图示：

案例：

class  Dog    //定义了一个Dog类
{
	//1.静态特征：属性
	//private:这个访问修饰符，是私有的，只能在类内访问
	//public:公共的，可以在类外访问,实际是有问题的
	public String name="旺财"; //字符串类型  变量名
	public String color="白色"; //颜色
	public int age=28;      //年龄

	//2.动态行为：方法
	//2.1 void:不返回任何类型 方法名
	public void printInfo(){
		System.out.println("狗名："+name);
		System.out.println("颜色："+color);
		System.out.println("年龄："+age);
	}
	//2.2 有参数 无返回值的方法,参数：food(食物)
	public void eat(String food){
		System.out.println(name+"吃"+food);
	}
	public void setName(String xingming){
		//this:代表当前对象;name:属性；xingming:参数
		this.name=xingming;
	}
	//2.3无参数 有返回类型的方法;
	public String getName(){
		return name;
	}
	//无参数就是()里面没有内容
	//有返回值就是方法前面有类型，不是void的
	//2.4有参数 有返回类型值的方法;自动狗，1 2 3,
	//狗会根据主人的指令，自动叫1 2 3次;
	public String shout(int num){
		String result="";
		for(int i=1;i<=num;i++){
			result+="汪";
		}
		return result;
	}
}

class Zoo  //定义一个动物园类 
{
	//动物园有大门;我们在使用的时候，只需要去运行含有main方法
	//类即可，java会自动把其他相关的类调用进行编译
	public static void main(String[] args) 
	{
		//关门放狗
		//Dog类是引用数据类型，除了基本数据类型之外，都是引用类型
		//引用数据类型的特征，就是可以被new,在内存分配空间
		//1.创建Dog类的一个对象dog,并且在内存进行分配空间
		Dog dog=new Dog();
		//2.给对象的属性赋值
		//dog.name="花花";
		dog.color="黄色";
		dog.age=7;
		//3.调用dog对象的方法
		dog.printInfo();
		dog.eat("骨头");
		dog.setName("滴滴");
		//dog.getName()返回类型就是String
		System.out.println(dog.getName());//println(字符串)
		//调用有参数  有返回值的方法;
		System.out.println(dog.getName()+"叫："+dog.shout(33));
	}
}

四.作业

4.1 实现如下效果，建立四个类（英雄类：Hero,武器类：Weapon,怪物类：Monster 测试类Test

我是英雄，我的基本信息如下：
姓名:李小侠,生命值:300
我是武器，我的基本信息如下：
武器名：死神镰刀,攻击力：12
我是怪物，我的基本信息如下：
姓名:小龟,生命值:300,类型潜水类
李小侠需要砍25刀才能干掉小龟

4.2 提前预习第九章 猜数字的面向对象实现

第八章：static和final

一.知识点

1.包的概念

2.final

3.static

二.重点

1.包

2.static

三.内容

1.包的概念和使用

java主要用于网站、WEB开发；www.taobao.com

建立包：com.taobao.www;域名反转格式；

使用包：package 包名;

导入包：import 包名.类名;

import java.util.*;

package chapter09;

public class Hero {
	public String name;
	public int level;
	
	public void say(){
		System.out.println(name+","+level);
	}
}

package com.aaa.www;
//chapter09包 
//com.aaa.www 外面的类

import chapter09.Hero;

public class TestGame {

	public static void main(String[] args) {
		Hero junjie=new Hero();
		junjie.name="奥利奥 ";
		junjie.level=222;
		junjie.say();
	}

}

2.final常量修饰符

含义：最后的，最终的; 决定性的; 不可更改的；

finally:最终；

const;

目的：提高安全性;

1. final修饰符可以修饰静态变量、实例变量和局部变量，分别表示静态常量、实例常量和局部常量。
2. final类型的成员变量必须显式地初始化，否则将导致编译错误。
3. final变量只能被赋值一次。
4. 在定义final常量时，一般以大写字母命名，且多个单词之间使用下划线“_”隔开
5. final可以修饰类,类不能继承final类。
6. final也可以修饰方法,子类不能重写final方法。

public class TestFinal {
	//1.定义变量：成员变量;属于类：TestFinal
//	final int i;//成为fianl类型常量;fianl修饰成员变量必须被初始化 
	final Integer MAX_VALUE=8844;
	final Integer TYPE=1;  //final常量：全部大写;
	
	public static void main(String[] args) {
		//局部变量：属于main（）
		int jj=2;
		TestFinal tf=new TestFinal();
		tf.say();
	}
	public void say(){
		final int jjj=2;
		//int i=2;如果存在成员变量和局部变量同名的情况，当调用包含局部变量的方法时候，优先调用局部变量。
		//System.out.println("i="+i);
//		jjj=222;//不能再次被赋值，因为是常量;
		
	}
}

3.static

3.1为什么要用static,现实世界，有公共设施（公园、卫生间、汽车等）资源共享；java项目编程中不想去一直创建方法、类，实现多个类的代码共享；就可以使用static。

优点：而static重点在于共享，方便。在类里创建一个static修饰的函数，则可以直接通过类名访问，该类new出来的对象，也可以共享static函数，或者static修饰的共有属性。

同样可以修饰成员变量–>静态成员变量

局部变量–》？

成员方法–》静态成员方法;

static不能修饰类;

1.有静态成员变量的类，new的时候，都是静态区成员变量的副本，实际还是指向静态区的静态变量。

2.static不能修饰局部变量;

3.静态方法只能访问静态变量;

4.非静态方法,可以直接访问静态变量

5.final可以修饰类

6.当我们访问静态属性或静态方法的时候，使用类名.属性/类名.方法名;使用对象的.属性/对象.方法名也可以.

系统源码时刻：

我们使用源码来获得随机数：

四.作业

课后作业：

第九章 猜数字游戏

1.计算机类

/**
 * 计算机类：自动出拳
 * 1:剪刀;2.石头;3.布;
 * @author teayear
 */
public class Computer {
	public String name;//名；
	public int score;//成绩
	public int value;//出拳值;
	//自动出拳;
	public void showFist(){
		//随机数：[1,3]
		int sjs=(int)(Math.random()*3)+1;
		this.value=sjs;	 //根据随机数产生的1 2 3，输出剪刀 石头  布 
		switch(sjs){
			case 1:System.out.println(this.name+"出拳：剪刀");break;
			case 2:System.out.println(this.name+"出拳：石头");break;
			case 3:System.out.println(this.name+"出拳：布");break;
		}
	}
}

2.玩家类

import java.util.Scanner;

/**
 * 用户类
 * @author teayear
 */
public class Customer {
	public String name;  //玩家姓名
	public int score;  //成绩;
	public int value;  //出拳值;
	//出拳
	public void showFist(){
		Scanner input=new Scanner(System.in); //已经接受用户的输入;1 2 3
		int num;
		do{
			System.out.println("1、剪刀 2、石头 3、布(输入相应数字):");
			num=input.nextInt(); //hasNextInt();也可以加下;
			switch(num){
				case 1:System.out.println("你出拳：剪刀");break;
				case 2:System.out.println("你出拳：石头");break;
				case 3:System.out.println("你出拳：布");break;
				default:System.out.println("你的输入有误！");break;
			}
		}while(num<1 || num>4);
		this.value=num;
	}
}

3.游戏主控类Game

import java.util.Scanner;
/**
 * 主游戏界面定义：
 * @author teayear
 */
public class Game {
	//1.属性;
	public Customer player;   //游戏主控类：玩家对象;
	public Computer computer;  //计算机对象;
	
	public int count;	//对局次数
	//用户输入对象input
	Scanner input=new Scanner(System.in);
	//2.1  欢迎方法;
	public void welcome(){
		System.out.println("********************************");
		System.out.println("*******      猜拳，开始           *******");
		System.out.println("********************************");
	}
	//2.2初始化方法;
	public void init(){
		computer=new Computer();
		player=new Customer();
		
		System.out.println("出拳规则：1、剪刀 2、石头 3、布");
		String compName="";
		System.out.print("请选择对方角色(1、刘备 2、孙权 3、曹操):");
		int num=input.nextInt();
		
		do{
			switch(num){
				case 1:compName="刘备";break;
				case 2:compName="孙权";break;
				case 3:compName="曹操";break;
				case 0:System.out.println("选择错误，请重新输入!");break;
			}
		}while(num<1 || num>4);
		
		computer.name=compName;
		//设置玩家姓名
		System.out.print("请输入你的姓名：");
		player.name=input.next();
		System.out.println(player.name+"  VS  "+computer.name+"  对战");
	}
	//2.3 开始游戏,可以先不写;
			public void play(){
				String answer=""; //定义变量：接受用户的输入，是否继续下一次游戏;
				System.out.println("要开始吗？(y/n):"); //是否开始;
				answer=input.next();
				do{
					//开始PK
					this.player.showFist();
					this.computer.showFist();
					
					int result=(player.value-computer.value);
					//success:1  3;3 2
					if(result==1 ||result==-2){
						System.out.println("^.^你太牛了,你胜出!");
						this.player.score++;
					}else if(result==0){
						System.out.println("平局");
					}else{
						System.out.println("不好意思哦 ，你失败啦!");
						this.computer.score++;
					}
					this.count++;	//总局数加1
					System.out.println("是否开始下一轮？(y/n):");
					answer=input.next();
				}while(answer.equals("y")||answer.equals("Y")); //当非y/Y的时候退出;
			}
			//结束游戏;
			public void report(){
				System.out.println(this.player.name+"   VS  "+this.computer.name);
				System.out.println("对战次数："+this.count+"平局次数："+(this.count-player.score-computer.score));
				System.out.println("***** 名字   分数*****");
				System.out.println(this.player.name+"ttt"+this.player.score);
				System.out.println(computer.name+"ttt"+this.computer.score);
			}
}

4.测试题，程序入口

/**
 * 测试游戏开始
 * @author teayear
 */
public class TestGame {
	public static void main(String[] args) {
		Game game=new Game();
		game.welcome();
		game.init();
		game.play();//代码逐步实现
		
		game.report();  //代码逐步实现，可以先不写该代码
	}
}

//游戏主控类：玩家对象;
public Computer computer; //计算机对象;

public int count;	//对局次数
//用户输入对象input
Scanner input=new Scanner(System.in);
//2.1  欢迎方法;
public void welcome(){
	System.out.println("********************************");
	System.out.println("*******      猜拳，开始           *******");
	System.out.println("********************************");
}
//2.2初始化方法;
public void init(){
	computer=new Computer();
	player=new Customer();
	
	System.out.println("出拳规则：1、剪刀 2、石头 3、布");
	String compName="";
	System.out.print("请选择对方角色(1、刘备 2、孙权 3、曹操):");
	int num=input.nextInt();
	
	do{
		switch(num){
			case 1:compName="刘备";break;
			case 2:compName="孙权";break;
			case 3:compName="曹操";break;
			case 0:System.out.println("选择错误，请重新输入!");break;
		}
	}while(num<1 || num>4);
	
	computer.name=compName;
	//设置玩家姓名
	System.out.print("请输入你的姓名：");
	player.name=input.next();
	System.out.println(player.name+"  VS  "+computer.name+"  对战");
}
//2.3 开始游戏,可以先不写;
		public void play(){
			String answer=""; //定义变量：接受用户的输入，是否继续下一次游戏;
			System.out.println("要开始吗？(y/n):"); //是否开始;
			answer=input.next();
			do{
				//开始PK
				this.player.showFist();
				this.computer.showFist();
				
				int result=(player.value-computer.value);
				//success:1  3;3 2
				if(result==1 ||result==-2){
					System.out.println("^.^你太牛了,你胜出!");
					this.player.score++;
				}else if(result==0){
					System.out.println("平局");
				}else{
					System.out.println("不好意思哦 ，你失败啦!");
					this.computer.score++;
				}
				this.count++;	//总局数加1
				System.out.println("是否开始下一轮？(y/n):");
				answer=input.next();
			}while(answer.equals("y")||answer.equals("Y")); //当非y/Y的时候退出;
		}
		//结束游戏;
		public void report(){
			System.out.println(this.player.name+"   VS  "+this.computer.name);
			System.out.println("对战次数："+this.count+"平局次数："+(this.count-player.score-computer.score));
			System.out.println("***** 名字   分数*****");
			System.out.println(this.player.name+"ttt"+this.player.score);
			System.out.println(computer.name+"ttt"+this.computer.score);
		}

}

## 4.测试题，程序入口

/**

• 测试游戏开始

• @author teayear
  */
  public class TestGame {
  public static void main(String[] args) {
  Game game=new Game();
  game.welcome();
  game.init();
  game.play();//代码逐步实现

   game.report();  //代码逐步实现，可以先不写该代码
  

  }
  }

最后

以上就是会撒娇水杯为你收集整理的JAVA语言程序设计基础入门技术教程JAVA语言程序设计基础第一章：JAVA入门基础–开山篇第二章：数据类型、变量和运算符第三章：分支控制语句第四章：循环语句第五章：数组第六章：常用类第八章：static和final第九章 猜数字游戏的全部内容，希望文章能够帮你解决JAVA语言程序设计基础入门技术教程JAVA语言程序设计基础第一章：JAVA入门基础–开山篇第二章：数据类型、变量和运算符第三章：分支控制语句第四章：循环语句第五章：数组第六章：常用类第八章：static和final第九章 猜数字游戏所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。