2019年7月总结

最新推荐文章于 2023-04-18 16:40:26 发布

王山而3611

最新推荐文章于 2023-04-18 16:40:26 发布

阅读量1.6k

点赞数 1

分类专栏： 7月总结

本文链接：https://blog.csdn.net/a790676316/article/details/98397608

版权

7月总结专栏收录该内容

1 篇文章 0 订阅

订阅专栏

20190710 DAY 1
Java se:
1、linux（重要性）
2、Jave se：
Jave基础部分
Java面向对象部分
Java高级特性

今天进入Java部分，今天目标：
1、了解Java历史
2、Java编程，我们为啥要学习他
3、Java开发的准备工作----环境的搭建
----开发环境的搭建（编辑器的使用）
----运行环境（jdk的安装和配置）
4、第一个Java程序—hello world
5、变量、常量
6、常见的运算符

软件和课件的准备工作
在java基础部分，要求如下（动手）：
程序以动手为主（先写会，再问为什么）
wwwh（what why when\where how）
先抄老师的代码
window开发代码为辅
在linux下使用vim工具进行java

编程语言的历史
一代编程语言（二进制）
二代编程语言（面向机器的语言）直接操作硬件，所以很难用
三代编程语言，高级语言（C语言），面向过程的编程语言
面向对象的编程语言
java的历史
1992年 sun(斯坦福大学网络公司)想竞标机顶盒项目，想设计
一个全新的编程语言，设计出一门编程语言
1994年硅谷大会橡树oak→java
1995年发布jdk的1.0版本之后开始全球流行

sun (java) 2008年被oracle公司收购74亿

   目前已经到12这个版本

jdk版本 1995 1.0
2005 5.0
2011 8.0（国内大多数公司使用的都为8.0版本）

所以咱们的学习以jdk8为主。

环境的安装和配置：
1、下载安装包（一定要在官网下载）建议使用64位架构
因为32位的性能远远不如64位的，2^32与264的比较，可想而知

window：
1、jdk安装，注意路径不要出现中文、特殊符号
2、进行环境变量的配置

电脑-->属性-->高级-->环境变量
创建一个JAVA_HOME选项
	1、JAVA_HOME：就是你安装的jdk的主目录D:\javajdk
	2、path追加
	 path = path;%JAVA_HOME%/bin

win10系统以下的版本：(win7)
	Path：%JAVA_HOME%\bin;

linux：
下午
jdk、jre

1、编程历史
2、java发展史
3、jdk的安装
jdk（java development kit）java开发工具
jdk：
java源码
各种内库
jre（java runtime environment）java运行环境
JVM（java virtual machine）java虚拟机
window安装和配置jdk
1、下载jdk包
2、安装jdk包
注意路径问题（尽量不要使用特殊符号）
3、配置环境变量（重点，必须掌握）

Linux下jdk的安装配置（CentOS）
1、如果要使用开源的open-jdk，请安装open-jdk
如果不使用open-jdk，请先卸载
2、如果安装Oracle公司的jdk，那么请先卸载jdk
如果使用的是.rpm包，则直接安装即可，什么配置都不需要
rpm -ivh jdk1.8xxxx.rpm

如果使用tar包安装（店家推荐）
1、解压tar
2、进行环境变量的配置（重要，必须掌握）
     如果需要配置成用户级别的环境变量（不推荐）
     在这里配置：vim ~/.bash_profile

     一般建议配置成系统级别的：
     vim /etc/profile

     在最后添加如下代码：
     export JAVA_HOME=java的主目录
     export PATH=${PATH}:$JAVA_HOME/bin
     保存退出

     重启：source /etc/profile

    3、测试是否成功
        java -version
	javac -version

第一个程序的编写:
//类名称（Test）必须和文件名（Test02.java）保持一致
//写代码成对编写，保持缩进
public class Test {
//main函数是java程序的入口
//java代码中大写敏感
public static void main(String [] args) {
System.out.println(“Hello world\n”);
System.out.println("\t-------------");
System.out.println("-------------");
}
}
\t：缩进一个table \n：换行

当java代码书写完成首先需要编译
javac Test.java //编译一个 java Test

盘符号: 就可以到某个盘如果想去H盘 h:

代码管理：
window下，将代码写在一个非c盘的目录下，
window下，路径跳转问题，如果跨盘符，请使用"盘符："完成
cd xxx

后缀名一定要放开，修改为.java


linux下 vim编辑器一定要会用

作业：1、一定学会jdk在不同系统的安装和配置 √
2、将第一个程序必须写会 √
3、打印各种界面 windows和linux √
4、复习linux
软件的安装
文件的操作
网络的配置

20190711 DAY 2
内容回顾：
1、编程语言的发展历史（了解）
2、Java编程的发展历史
3、Java的版本 jdk版本1.8
4、jdk的安装和配置
window下的安装：下一步下一步
配置问题： JAVA_HOME=java的主目录
path追加
path = path;%JAVA_HOME%/bin
linux下的安装：
rpm（不推荐）
tar.gz（店家推荐）
/opt
/soft
/usr/local/ 因为在环境变量中可以直接用
tar -zxvf jdk1.8.xxx.tar.gz
ln -s 软链接

（不推荐）用户级别配置（~/.bash_profile）：
		        export JAVA_HOME=/usr/local/jdk
			export PATH=${PATH}：$JAVA_HOME/bin
						
		  启动：source ~/.bash_profile

			此时只有root和用户才可以访问

		全局配置（/etc/profile）：
				export JAVA_HOME=/usr/local/jdk
				export PATH=${PATH}：$JAVA_HOME/bin
				source /etc/profile
		
		测试jdk是否安装成功：
				java -version
				javac -version

	1、第一个java程序：
		1.创建一个文本文档（Test.java）
	public class Test {
		public  static void.main(String [] args)  {
		     System.out.print("Hello world\n");
		     System.out.println("Hello world");
		}
	}

\t：缩进一个table \n：换行

	2、xxx.java   #java的源代码
	     javac    #java 的编译命令
	     javac xxx.java #编译xxx.java字节

1、java语言的特点：
1、开放的
2、开源的
3、分布式
4、面向对象的
5、跨平台的（sum公司为大家提供不同平台的虚拟机JVM）

今天目标：
注释
变量
数据类型
类型转换
常见运算符
三大流程
顺序
分支
循环

1、注释（标注的解释）：
1、单行注释 //注释
2、多行注释 /* 注释 */

public class zhushi {
public static void main(String[] args ) {
//这个就是单行注释
//Syst.out.print(“这行代码会输出吗”);
System.out.print (“hello xiaoxiaokong”);
/*
//多行注释
1
1
1
*/
System.out.print(“xiaoxiaokong”);
System.out.print(“xiaoxiaokongaaaaaaaaaa\n”);
}
}

2、变量
概念：在程序运行过程中，允许值发生改变的量
定义变量：
//在定义变量的同时赋值
数据类型变量名称 = 变量值；
（= 赋值号）
//初始化
int a = 10；
System.out.println（a）；

	//先定义
	int b;
	//在赋值
	b = 30; 等价于 int b = 30;
变量的类型（先不讲）
变量的命名规则：
	  int 变量名称 = 10 ;

在java中，变量的命名是有规范的
	1、变量只有大小写、数字、_（下划线）组成
	2、不能以数字开头
		int a = 0 （√）
		不可以出现 int 0 = a （×）
	3、不能使用关键字和保留字
	4、命名尽量有意义
	5、变量命名推荐使用小驼峰法
		userName
		userAge
		userAddress
	       还存在一种下划线命令规范：
		user_name
		user_age
		user_address
	补充：java中 类 的命名一定要使用大驼峰法
		Test
		UserManger

public class bianliang {
public static void main (String [] args) {
//定义变量 a
//定义了一个变量a，类型是整数,值是10
int a = 10 ;
System.out.println(a);
//定义一个变量b，类型是int
int b;
//给变量b 赋值30
b = 30;
System.out.println(b);
}
}

数据类型： bit（位） b与B 差了8位百兆宽带is bullshit
8b=1B（byte）字节
基本数据类型：
四类八种
整型：（1字节只能存255个数）
byte（B） 1 字节
short（short int） 2 字节
int 4 字节
long（long int） 8 字节

	    浮点型（小数）：
			float 单精度浮点数  4个字节
			double 双精度浮点数 8个字节

	   布尔类型：
		boolean  值：true（真） false（假）

	   字符： char 值就是被单引号引起来的单个字符 ''

引用数据类型（复合）：
	对象，万物皆对象
	字符串
	数组
	list
	set
	map
	...

和老师一起敲的
public class ceshi {
public static void main(String[] args){
//定义一个我们的字节数变量
byte a = 10;
System.out.println(a);
// byte b = 1000; //错误，因为byte范围是-128~127之间
short b = 1000;
System.out.println(b);
//定义一个整型，默认是int
int c = 10000;
//long类型建议后加L
long d =100000L;

              System.out.println("----------------");
              //浮点数默认是double 精度高
              float f1=99.99f;

              //定义一个双精度浮点数
              double d1 = 63.23;
              System.out.println(d1);

              // isTrue 是真
              boolean isTrue = true ;
          
              // isFalse 是假
              boolean isFalse = false ;

              //字符类型
              char c1 = 'a';
              char c2 = 'A';
              char c3 = '中';
              //char c4 = '中国' //错误，字符只能单个字符组成

类型转换
由低到高的类型会自动转换 (最后赋值时一定要赋给高的)
char<byte<short<int<long<float<double

public class Test05 {
public static void main(String [] args) {
byte a = 10;
int b = 20;
int c = a + b ;//正确
//int c = a + b ; //正确
//byte c = (a+b);//错误
byte d =(byte)(a+b);
//System.out.println(b);//错误应该给高级别的c赋值输出，因为int>byte
System.out.println(d);
}
}

内容回顾：
1、java中注释的使用
单行注释：//
多行注释：/* 多行注释 /
文档注释：/! 文档注释 */
2、变量的使用：
1、什么是变量
2、变量的定义
数据类型变量名称 = 变量值;
1.先定义后赋值
long a;
a = 10L;
2.初始化
int b = 20;
3、java的数据类型

面试题：
请使用两种方式求单个字符’斌’的Unicode码
思路：
char a = ‘斌’;

    a + 1 - 1

答案：
public class mianshiti {
public static void main (String[] args) {
char a = ‘斌’;
//使用自动类型转换
int res = a + 1 - 1;
System.out.println(res) ;
int res2 = (int) a ;
System.out.println(res2) ;
}
}

作业：求出你的名字的Unicode码。
答：
张瑞斌
[zhangruibin@zhangruibin javazuoye]$ vim mianshiti.java
[zhangruibin@zhangruibin javazuoye]$ javac mianshiti.java
[zhangruibin@zhangruibin javazuoye]$ java mianshiti
张：
24352
24352
瑞：
29790
29790
斌：
25996

常见运算符：
1、算数运算符 + - * /(整数) %(求余)

public class Test07 {
public static void main(String[] args) {
double a = 60;
double b = 40;
System.out.println(a + b) ;
System.out.println(a - b) ;
System.out.println(a * b) ;
System.out.println(a / b) ;
System.out.println(a % b) ;
}
}

[zhangruibin@zhangruibin javazuoye]$ vim Test07.java
[zhangruibin@zhangruibin javazuoye]$ javac Test07.java
[zhangruibin@zhangruibin javazuoye]$ java Test07
100.0
20.0
2400.0
1.5
20.0

2、关系运算符（比较运算符）：
>  <  <=  >=  ==(等于)  !=（不等于）

已敲：
public class guanxiyunsuanfu {
public static void main(String[] args) {
int a = 10 ;
int b = 20 ;
int c = 11 ;
System.out.println(a > b);
System.out.println(a < b);
System.out.println(a >= c);
System.out.println(a <= c);
System.out.println(a == c);
System.out.println(a != c);
System.out.println(a = c);
}
}
输出：
[zhangruibin@zhangruibin javazuoye]$ vim guanxiyunsuanfu.java
[zhangruibin@zhangruibin javazuoye]$ javac guanxiyunsuanfu.java
[zhangruibin@zhangruibin javazuoye]$ java guanxiyunsuanfu
false
true
false
true
false
true
11
3、逻辑运算符
与（并且）或（或者）非（取反）
&& || !
4、赋值运算符（级别很低）
= //表示将右侧的值服给左侧
+= //a += 10; 等价于 a = a + 10
-= //a -= 10; 等价于 a = a - 10
*= //a *= 10; 等价于 a = a * 10
/= //a /= 10; 等价于 a = a / 10
%= //a %= 10; 等价于 a = a % 10

5、自加和自减运算符
	int i = 10;              在加加和减减运算符中					
	i++;				 前加加 先自加1在赋值				
	++i;				 前减减 先自减1在赋值
	i--;
	--i;
	
	int b;
	int b = i++;
	int c = ++i;
	int d = i--;
	int e = --i;

已敲：
public class zijiazijian {
public static void main(String[] args) {
int i = 10 ;
i++;
System.out.println(i) ;
++i;
System.out.println(i) ;
i–;
System.out.println(i) ;
–i;
System.out.println(i) ;
System.out.println("------------------------") ;

            int b = i++; // int b = i ; i += 1;
            System.out.println(i) ;
            System.out.println(b) ;
            int c = ++i; // i += 1 ; int c = 1;
            System.out.println(i) ;
            System.out.println(c) ;
            int d = i--; // int d = i ; i--
            System.out.println(i) ;
            System.out.println(d) ;
            int e = --i; // i-- ; int e
            System.out.println(i) ;
            System.out.println(e) ;

    }

}
底层原因是因为前加加（前减减）优先级别很高
后加加（后减减）优先级别很低

已敲：
//从控制台上接受两个数，并且输入他们的和
//导入对应的11包
import java.util.Scanner;
public class Test11 {
public static void main(String[] args) {

            Scanner sc = new Scanner(System.in) ;
            System.out.print("请输入第一个数: ") ;
            int a = sc.nextInt(); // 表示从控制台上输入一个数字
            System.out.print("请输入第二个数: ") ;
            int b = sc.nextInt(); // 表示从控制台上输入两个数字
            System.out.println("a + b = "+(a + b)) ;
    }

}

作业1：根据天数（从控制台上输入）计算周数和剩余天数 zuoye0711 √
作业2：根据已知圆的半径radius（控制台上输入），求其面积和周长 zuoye07111 √
作业3：控制台上输入两个数，求和、差、积、商、余 zuoye071111 √
作业4：在控制台输入成绩，判断学生的学习情况 zuoye0711111 √
100满分
0 0分
1~59不及格
60~70及格
70~80中
90~100秀儿
注意：错误的判断
作业5：用户输入两个数a b。如果a可以被b整除或a+b>1000，则输出a,否则输出b zuoye0711111 √
作业6：看pdf1

三元（目）运算符: 如果一个值成立取值1 否则取值2
变量 = 表达式?值1:值2 ;

int a =10 > 20 ?50:80;
a?
if 10 > 20 {
	int a = 50 ;
if 10 <= 20 {
	int a = 80 ;
	}

程序流畅：
顺序（代码都是由左而右、从上到下执行）
分支（选择）
单分支
if（条件）{
// 当条件为真时，执行花括号内代码
}
双分支
if（condition）{
//成立
} else {
//成立
}
三（多）分支
if (条件1) {

		} else if (条件2) {

		} else if (条件3) {

		} else if (条件4) {

		}else{
		
		}    
		


循环

20190713 DAY 3
内容回顾：
java se（java platform standard edition）java标准版
java ee（java platform enterprise edition）java企业版
java me
1、各种历史典故
2、jdk的安装和配置（重点，要会）
3、第一个程序 hello world
4、变量
什么是变量
变量的定义
变量的命名规则
变量只有大小写、数字、_（下划线）组成
不能以数字开头
不能使用关键字和保留字
命名尽量有意义
变量命名推荐使用小驼峰法
5、运算符
1.算数运算符 + - * /(整数) %(求余)
2.关系运算符（比较运算符） < > >= <= == !=
3.逻辑运算符：与（并且）或（或者）非（取反）
&& ||（短路或） !
& |
&&和&一样，建议使用&& || 来判断
4.赋值运算符（级别很低）
=
+=
-=
*=
/=
%=
5.自加和自减运算符
前加加优先级很高。
后加加优先级很低
三大流程：
顺序：从左到右，从上到下运行的
选择结构：
单分支
if（条件） {

			      }
			双分支
				if（条件） {

				} else {
					//条件不成立

				}
			三（多）分支
				if（） {

				} else if（） {

				} else if（） {

				} else if（） {

				} else {

				}

今天的目标：
1、多分支的switch语句块
2、循环语句
for
while
do while

	多层循环

switch
switch(变量) {
case 常量1:
//代码块
break;
case 常量2:
//代码块
…
还有条件再加 default:

注意：
1、switch语句一般需要break
2、如果还有其他条件，请加入default
3、switch中的变量类型：
在jdk1.5之前，只能是char、byte、short、int
在jdk1.5之后，增加了枚举类型
在jdk1.7之后，增加了字符串（String）
目前jdk12，不支持long、浮点型

课堂练习：
输入成绩，完成学生的学习情况判断 ketanglianxi/TestScore.java

选择结构：
if
if else
if else if else
switch

总结：
描述几种分支结构的语法和执行过程？
什么情况下会使用多重if选择结构？
多重if选择结构和switch选择结构的区别和适用场合是什么？

循环：
java中的循环有三种：
for
while
do…while

for：
for（定义一个变量;判断是否符合条件;条件升级）{
//循环体
}
如：在控制台上输出0-9 这10个数
答：public class TestFor {
public static void main(String[] args) {
//for 循环
for (int i = 0; i < 10; i++) {
System.out.println(i) ;
}

}

输出：
[zhangruibin@zhangruibin ketanglianxi]$ vim TestFor.java
[zhangruibin@zhangruibin ketanglianxi]$ javac TestFor.java
[zhangruibin@zhangruibin ketanglianxi]$ java TestFor
0
1
2
3
4
5
6
7
8
9

例题：输出0-99数字：
public class TestFor2 {
public static void main(String[] args) {
int i = 0;
for (i=0;i<100;i++) {
System.out.print(i + “\t”);

            }
    }

}

早晨内容：
1、switch
2、循环
for
while
do…while
-----------------------------
for(int i = 0; 条件；i++) {
1 2 3
//循环体 4
}
1 2 4 3 2 4 3 2 4 3直到条件不满足循环终止

-----------------------------
while
	while(条件) {
		//循环体
	}

课堂案例：使用while循环完成1~100的和
方法1：
public class TestWhile {
public static void main(String[] ags) {
int sum = 0;
for(int i=1;i<=100;i++) {
sum +=i ;
}
System.out.println("1~100的和是 " +sum);
}
}

方法2:
public class TestWhile {
public static void main(String[] ags) {
int sum = 0;
int index = 0;
while (index <=100){
sum=sum+index;
index++;
}
System.out.println("1~100的和是 " +sum);
}
}

-----------------------------

do…while循环

do {

}while（条件）;

练习：求1~10的积： TestDoWhile.java
public class TestDoWhile {
public static void main(String[] args) {
//求0~100的积
long sum = 1;
int i = 1 ;
do {
sum *=i;
i++;
}while(i<=10);
System.out.println(“0~100的积是：”+ sum);
}
}

注意：do while 不管条件是否符合。至少会执行一次
一般而言，主要用来做人机交互

练习：请使用while和for完成1~100之间的偶数的和 TestWhileFor.java
public class TestWhileFor {
public static void main(String[] args) {
int sum = 0;
for (int i = 0;i <=100;i++) {
//每次循环进来
//判断i是否为偶数
if(i % 2 == 0) {
sum +=i ;
//System.out.println(“1~100的和是：”+ sum);
}
}
System.out.println(“0~100的偶数和：”+ sum);
}
}

作业1：Test01.java
输入赵本山的考试成绩，显示所获奖励
成绩==100分，爸爸给他买辆车
成绩>=90分，妈妈给他买MP4
90分>成绩>=60分，妈妈给他买本参考书
成绩<60分，什么都不买
作业2：Test02.java
张三为他的手机设定了自动拨号
按1：拨爸爸的号
按2：拨妈妈的号
按3：拨爷爷的号
按4：拨奶奶的号
作业3：循环输入某同学S1结业考试的5门课成绩，并计算平均分Test03.java
作业4：请使用for完成1~10之间的奇数的积 Test04.java
作业5：请从控制台输入一个数。判断是偶数还是奇数，是质数还是合数 Test05.java
提示：从2开始，只能被1和它本身除尽的数，是质数（素数）
作业6：求1~100不能被3整除的数之和 Test06.java

break、continue关键字的使用：

break：
1、break 打断switch语句的作用
2、终止循环的作用

continue：
中断本次（一次）循环，进入下次循环

课堂练习：求1~20之间3的倍数
public class TestBreak {
public static void main(String[] args) {
//求1~20之间3的倍数
for(int i =1;i<20;i++) {
if(i%3==0){
System.out.println(i+“是3的倍数”);
}
}
}
}

练习：Test01.java
请输入一个数字，先判断是偶数还是奇数
如果是偶数，请判断从1到该数是3的倍数有哪些
如果是奇数，请判断从1到该数是5的倍数有哪些
import java.util.Scanner;

public class Test01{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print(“请输入一个数:”);
int a =sc.nextInt();
if(a%20){
for(int i = 1;i<=a;i++){
if (i%30){
System.out.println(“从1到该数是3的倍数有：”+i);
}
}
} else {
for(int i = 0;i<=a;i++){
if(i%5==0)
System.out.println(“从1到该数是5的倍数有：”+i);
}
}
}
}

练习：打印一个表格
根据用户输入的数字
1 11 111
2 22 222
…
n nn nn*n
import java.util.Scanner;

public class TestN {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in) ;
System.out.print(“请输入数字：”);
int num = sc.nextInt();
System.out.println("\t数字\t\t平方\t\t立方");
for(int i = 1 ;i<=num;i++){
System.out.println("\t"+ i +"\t\t"+(ii)+"\t\t"+(ii*i));
}
}
}

作业7：请使用循环完成如下图案的打印
*
**

import java.util.Scanner;
public class Start{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println(“请输入参数”);
int layer = sc.nextInt();
for(int i = 1;i <= layer;i++) {
//第一个循环，控制行
for(int j = 1;j<=i;j++) {
System.out.print("*");
}
System.out.println("");
}
}
}

```
*
```

20190714 DAY 4
回顾昨日内容：
1、switch的使用
1、注意switch和if…else…if的一般使用常见场景
2、注意break关键字的使用
3、变量的类型问题
2、循环
for
for（第一个语句定义变量；条件判断；索引的变化）{

	}
while
	while（条件）{
	
	}
do...while

	do{
	
	}while();

讲解作业3：作业3：循环输入某同学S1结业考试的5门课成绩，并计算平均分
import java.util.Scanner;

public class Test03{
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
double sum = 0;
int count = 0;
for(int i=1;i<=5;i++){
System.out.print(“请输入S1结业考试的5门成绩”);
double score = sc.nextDouble();
sum+=score;
}
double avg=sum/5;
System.out.println(“您的五门成绩是：”);
}
}

讲解作业5：作业5：请从控制台输入一个数。判断是偶数还是奇数，是质数还是合数
提示：从2开始，只能被1和它本身除尽的数，是质数（素数）
import java.util.Scanner;
public class Test05 {
public static void main(String[] args) {
Scanner sc= new Scanner(System.in);
System.out.print(“请输入一个数（大于1的数）：”);
int num =sc.nextInt();

            //判断是偶数还是奇数            
            while(num<2){
                    //数据校验，防止误输入
                    System.out.print("请输入一个整数（大于1的数）");
                    num =sc.nextInt();
                    }
            //判断是偶数还是奇数
            if(num%2==0){
                    //说明是偶数
                    System.out.println(num+"是偶数");
                    //在偶数中，只有2 才是质数
                    if(num!=2) {
                            System.out.println("合数");
            }else {
                    System.out.println("2是质数");
            }

            }else{
                    System.out.println(num+"是奇数");

		boolean flag = true ;
                    //循环判断
                    for(int i = 2;i<num;i++){
                            if(num%i==0){
                            flag = false;
                            break;
                    }
    }
            if(flag){
                    System.out.println(num+"是质数");
                    }else{
                    System.out.println(num+"是合数");
                    }
            }
    }

}

练习：输入一个数字，判断是不是质数: Testzhishu.java
import java.util.Scanner;
public class Testzhishu {
public static void main(String[] args) {
Scanner sc= new Scanner(System.in);
System.out.print(“请输入一个数（大于1的数）：”);
int num =sc.nextInt();

            boolean flag = true ;
            for(int i =2;i<num;i++){
                    if(num%i==0){
                    flag = false;
                    break;
                    }
            }if(flag){
                    System.out.println(num+"这个数是质数");
                    }else{
                     System.out.println(num+"这个数是合数");
            }
    }

}

讲解作业7：
菱形：
import java.util.Scanner;
public class Print1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print(“请输入您要打印的层数：”);
int layer = sc.nextInt();

	for (int i = 1; i <= layer; i++) {
		int spaceNum = layer - i;
		for (int j = 1; j <= spaceNum; j++) {
			System.out.print(" ");
		}						
		int startNum = 2*i - 1;
		for (int j = 1; j <= startNum; j++) {
			System.out.print("*");
		}
		System.out.println("");
	}
	for (int i = layer - 1; i >= 1; i--) {
		int spaceNum = layer - i;
		for (int j = 1; j <= spaceNum; j++) {
			System.out.print(" ");
		}			
		
		int startNum = 2*i - 1;
		for (int j = 1; j <= startNum; j++) {
			System.out.print("*");
		}
		System.out.println("");
	}
}

}
空心菱形：
import java.util.Scanner;
public class Print2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print(“请输入您要打印的层数：”);
int layer = sc.nextInt();

	// 首先打印等腰三角形
	for (int i = 1; i <= layer; i++) {
		int spaceNum = layer - i;
		for (int j = 1; j <= spaceNum; j++) {
			System.out.print(" ");
		}						
		int startNum = 2*i - 1;
		for (int j = 1; j <= startNum; j++) {
			//System.out.print("*");
			// 判断是第一个或者最后一个
			if (j == 1 || j == startNum) {
				System.out.print("*");
			} else {
				System.out.print(" ");
			}
		}
		System.out.println("");
	}		
	for (int i = layer - 1; i >= 1; i--) {
		int spaceNum = layer - i;
		for (int j = 1; j <= spaceNum; j++) {
			System.out.print(" ");
		}						
		int startNum = 2*i - 1;
		for (int j = 1; j <= startNum; j++) {
			//System.out.print("*");
			if (j == 1 || j == startNum) {
				System.out.print("*");
			} else {
				System.out.print(" ");
			}
		}
		System.out.println("");
		
	}
}

}
十字菱形：
import java.util.Scanner;
public class Print3 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print(“请输入您要打印的层数：”);
int layer = sc.nextInt();

	// 首先打印等腰三角形
	for (int i = 1; i <= layer; i++) {
		int spaceNum = layer - i;
		for (int j = 1; j <= spaceNum; j++) {
			System.out.print(" ");
		}			
		
		int startNum = 2*i - 1;
		for (int j = 1; j <= startNum; j++) {
			// 判断是最后一行
			if (i == layer) {
				System.out.print("*");
			} else {
				// 判断是第一个或者最后一个
				if (j == 1 || j == startNum || j == (startNum / 2 + 1)) {
					System.out.print("*");
				} else {
					System.out.print(" ");
				}
			}
		}
		System.out.println("");
	}	
	for (int i = layer - 1; i >= 1; i--) {
		int spaceNum = layer - i;
		for (int j = 1; j <= spaceNum; j++) {
			System.out.print(" ");
		}						
		int startNum = 2*i - 1;
		for (int j = 1; j <= startNum; j++) {
			//System.out.print("*");
			if (j == 1 || j == startNum || j == (startNum / 2 + 1)) {
				System.out.print("*");
			} else {
				System.out.print(" ");
			}
		}
		System.out.println("");		
	}
}

}
圣诞树：
import java.util.Scanner;
public class PrintStree {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print(“请输入您要打印的层数：”);
int layer = sc.nextInt();
String tree = “”;

	// 首先打印等腰三角形
	for (int i = 1; i <= layer; i++) {
		int spaceNum = layer - i;
		for (int j = 1; j <= spaceNum; j++) {
			System.out.print(" ");
			if (i == 1) {
				tree += " ";
			}
		}						
		int startNum = 2*i - 1;
		for (int j = 1; j <= startNum; j++) {
			System.out.print("*");
			if (i == 1) {
				tree +=  "*";
			}
		}
		System.out.println("");
	}		
	// 打印树杆
	for (int i = 1; i <= layer; i++) {
		System.out.println(tree);
	}
}

}

打印九九乘法表：
public class Chengfabiao {
public static void main(String[] args) {
System.out.print(“请输入您要打印的层数：”);
int rows = 9;
for(int i =1;i<=rows;i++){
for(int j =1;j<=i;j++){
System.out.print(j+ “" +i+ “=” +ji+ " “);
}
System.out.println(”\n”);
}

}

常量：在程序运行过程中，不能发生改变叫做常量

public static final 数据类型 常量名称 = 常量值；

import java.util.Scanner;

public class GetPI {

    public static final int CONST = 4;

    public static void main(String[] args){
            double pi ;
            double  sum = 0;
            
            Scanner sc =new Scanner(System.in);
            System.out.print("请输入您要循环的次数：");
            int num = sc.nextInt();

            for(int i = 1;i<=num;i++){
                    int temp =2*i-1;
                    if(i%2==0){
                            temp=-temp;
                    }
                    sum += 1.0 / temp;
            }
                    pi= CONST*sum;
                    System.out.println("PI的值是："+pi);
    }

}

下午内容：
函数
1、什么是函数
2、函数的定义
3、函数的调用
4、函数的参数
5、函数的返回值
6、函数的重载（overload）

思考题：请判断200-980之间那些数字是质数
思考题2：输入一个数，判断是不是质数，如果是，请加21，再判断是不是质数，如果不是，请加31再判断是不是质数

如上代码的使用，过多重复多次使用，增加了代码的维护和开发成本
1、函数是什么：
函数是具有名称的代码块。具有特定功能的代码块
所以函数就是一个行为，一个动作，一个过程
2、函数的定义：

	public static 返回值类型 函数名称([参数列表]){
		//函数体
		
		[return 返回结果 ;]

		}

注意：java中，函数必须定义在类中（class后面就是类）

案例：

3、函数的调用
函数名称（[参数列表]）；
public class FunctionArgs {
public static void main(String[] args) {
sayHello(“呵呵”);

    }
    public static void sayHello(String msg){
            System.out.println("嗯嗯嗯好好好"+msg);
    }

}

4、函数的参数
函数可以没有参数，函数可以有一个参数，也可以有多个参数
注意：需要声明参数的类型

5、函数的返回值
函数可以没有返回值，请使用void关键字声明
如果函数需要返回值，return关键字返回结果，并且函数上声明返回值的类型
注意：Java中，函数只能返回在一个值

public class FunctionReturn {
public static void main(String[] args){
int sum = getSum(20,50);
System.out.println(“两者的和是：”+sum);
}

    //定义一个函数，计算两个整数想加的结果
    public static int getSum(int x, int y){
            return x+y;
    }

}

作业1：
请在控制台上输入两个数，并输入一个符号（±*/%）
定义五个函数

sc.nextInt();
sc.nextInt();
// 注意，next接受的是一个字符串
String op = sc.next();

switch(op) {
	case "+":
		sum();
		break;
	case "-":
		jianfa();
		xxx
}

作业2：将昨天打印*的代码封装成函数
作业3：100~1000范围内，能同时被5和6整除的数 zuoye03.java
作业4：计算PI zuoye04.java
作业5：文档中题以每天10道的速度完成（超纲的除外）
1~9题写完

函数的重载：
强数据类型语言中，大多数情况下都存在函数的重载
什么是函数重载（overload）
在编程中,把函数名称相同，参数的个数或参数的类型不同
要看个数和类型，不看型参

20190715 Day 5
内容回顾：
三大流程的题的练习
锻炼你们的判断和逻辑能力

函数

函数就是一个代码块，一块具有名称的解决问题的代码集合

//非静态函数不能调用静态函数

public static [返回值的类型|void] 函数名(参数列表){
//函数体

[return 返回值;]
}

注意：没有返回值就用void

函数名([实参列表])； //函数的调用
函数的返回值
函数的参数
函数重载（overload）同名函数看类型和个数，不看型参
函数的递归（暂时不讲）

作业讲解：
1、请在控制台上输入两个数，并输入一个符号（±*/%）
定义五个函数 zuoye01.java
2、100~1000内，同时能被5和6整除的数 zuoye03.java

1、什么是函数
具有特定功能的代码块
为什么会出现函数

输入一个数字，判断是质数还是合数
如果是质数+21 再判断是质数还是合数
如果是合数+31 再判断是质数还是合数

函数就是代码封装，将每一步都明确出来

函数的参数和返回值
参数是不是应该有？
要看函数需不需要，目前还不确定

例：用户输入半径，写两个函数，面积和周长
import java.util.Scanner;

public class hanShu {
public static final double PI=3.14;
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.print(“请输入圆的半径：”);
double a = sc.nextDouble();

                    double MianJi =kkk(a);
                            System.out.println(MianJi);
                    double ZhouChang=jjj(a);
                            System.out.println(ZhouChang);
            }

            public static double kkk(double r){
            return PI * r * r;

            }

            public static double jjj(double r){
            return 2* PI * r;
            }

}

回顾函数：
注意函数的使用，推荐写代码尽量将一个独立的功能封装为一个或者多个函数

下午目标：
数组：一系列数据的组合。

数组的定义：
数据类型 [] 数组名称 = new 数据类型[数组大小]

内存中有堆和栈
栈很小，java虚拟机里面的栈是512M（栈：先进后出、后进先出）

数组特点：
1、数字只能存储一种数据类型
2、数字长度一旦定义，固定下来，不可改动
3、数组申请的内存区域是连续内存（重要）

数组的元素的访问：
数组名称[下标] //下标从0开始计算，最大是数组大小-1

数组的大小（元素的个数）：
数组名称.length属性

数组的遍历：
一般使用循环完成数组的遍历

第一种申明数组的方式：
double[] arr1 = new double[10];

int arr2[] = new int[50]  //也对，但是不推荐

//数组初始化，在申明的同时赋值，所以大小由元素的个数决定，不需要单独说明
int[] arr3 = new int[]{1,2,3,100,1555}

课堂练习： lianXi01.java
从控制台接受10门成绩（数组），计算成绩的总和和平均分
*import java.util.Scanner;

public class lianXi01{
* public static void main(String[] args){
double[] xxxx = new double[10];
Scanner sc=new Scanner(System.in);
double sum =0;
for(int i=0;i < xxxx.length ;i++){
System.out.print(“请输入您的第”+(i+1)+“门成绩：”);
xxxx[i]=sc.nextDouble();
sum +=arr1[i];
}
System.out.println(“十门成绩总分:”+sum);
System.out.println(“十门成绩平均分：”+(sum / 10));
}
}

new关键字
用于定义数据类型的关键字
class //定义类的关键字
interface //定义接口
byte //字节
short //2个字节
int //4个字节
long //8个字节
float //4个字节
double //8个字节
char //2个字节
boolean //1个字节
void //无字节

用于定义数据类型值的关键字
true //真
false //假
null //空引用

用于定义访问权限修饰符的关键字
private //私有的
protected //受保护的
public //公共的

用于定义类，函数，变量修饰符的关键字
abstract //抽象的
final //最后的
static //静态的
synchronized //同步（asynchronize 异步）

用于定义类与类之间关系的关键字
extends //继承
implements //实现

用于定义建立实例及引用实例，判断实例的关键字
new //新的
this //自己
super //超类（父类）
instanceof // 判断类型

用于异常处理的关键字
try //尝试
catch //捕获，抓取
finally //最后的
throw //抛出（自己抛）
throws //抛出

用于包的关键字
package //包
import //打包

其他修饰符关键字
native //本地的
strictfp //
transient //
volatile //
assert //测试，断言

关键字：具有特殊含义的字
保留字：现在不用，后面可能要用

作业：
求Test10中的成绩最大值、最小值

Arrays类的讲解：
我们开始逐渐要学习使用一些系统内置的方法、类、接口等数据
查看帮助文档

20190711 Day 6

练习题讲解 bianchengti2019 /Ti08.java
import java.util.Random;
class TestTime {
public static void main(String[] args) {
// 在计算机在我们获取的时间戳
// 1970.01.01 00:00:00
/*long times = System.currentTimeMillis();
System.out.println(times);
long second = times / 1000 ;
System.out.println(second);

	long minutes = second / 60 ;
	System.out.println(minutes);
	long day = times / (1000*60*60*24);
	System.out.println(day);*/
	/**
		练习 / % 以及
		 System.currentTimeMillis();  // 获取的当前时间距离1970.01.01 00:00:00的毫秒数
		 System.nanoTime();	// 获取是纳秒数
	*/
}

}

随机数：

// 注意：计算机中获取的随机数都叫做伪随机数
// Math.random() 获取一个随机数，[0, 1)
//System.out.println(Math.random());
// 0~ 10
for (int i = 0; i < 20; i++) {
//System.out.println((int)(Math.random()10));
// 5~10
// 使用Math.random做区间随机数，min + (int)(Math.random()(max - min))
//System.out.println(5 + (int)(Math.random()*(11 - 5)));
}

	// 获取Random对象
	//Random r = new Random();
	//System.out.println(r.nextInt(10));
	//System.out.println(r.nextInt(100));


	/**
		1、System.currentTimeMillis()
		2、System.nanoTime();
		3、Math类
			Math.random()	
		4、util
			Random类
	*/

上了9天课程了
4天 linux //常规命令、系统配置、软件安装和配置
5天 javase //编程基础部分
–jdk的安装和配置
–变量
–数据类型
–常见运算符
–算术
–关系
–逻辑
–三元
–自加自减
–赋值
–位运算
–三大流程
–函数
–数组
---------------------------------编程基础部分结束----------------------------------------
Java面向对象：
java是一门面向对象的语言、静态语言、编译型的语言

1、what？什么是面向对象的语言？

回顾编程语言史：
第一代编程语言：机器语言二进制 0001010101
第二代编程语言：面向机器的语言使用了一些 add sum
第三代编程语言：C语言
C语言：面向过程的编程语言：
吃面：
烧水
和面
擀面
切面
下面
盛面
吃面

诞生了面向对象的编程语言（C++、C#、java、Python、ruby、php）

面向对象：本质就是让电脑以人认知世界的方法来编程（构建它的世界）

1、类（类别）：是一个抽象单位，不存在，是我们通过特征和行为分门别类得到的一个类别，类就是模板，存在的模型

2、对象：对象就是一个类的实例（实实在在的案例），对象是存在的

吃面
人
面
水
火

类的定义：

OO（Oriented Object）：面向对象
OOP（Oriented Object Programming）
OOA（）：面向对象分析
OOT（）：面向对象测试
OOD（）：面向对象设计

    /*在同一个xxx.java文件中 只能出现一个使用public修饰的类
    这个类就是xxx
    */

//使用class关键字定义类
//注意类的命名规则，大驼峰法

class TestObject{ ketang0717 /TestObject.java
public static void main(String[] args){
//得到一个对象
//使用new关键字，实例化一个对象
//对象类型对象名称 = new 类名称();
Person p1 = new Person();

            //给对象赋值    
            p1.name = "世羽梵";
            p1.age = 21;
            p1.weight = 60.0;
            p1.sex = "男";
            //对象方法调用，和函数类似
            p1.info();

    }

}

class Person{
//静态的特征
String name; //人的名字
int age; //人的年龄
double weight; //人的体重
String sex; //人的性别
/*
动态的特征，一般使用方法（函数）表示
*/
public String say(){
return"小小孔和小小斌";
}
public void info(){
System.out.println(“我的名字是：”+name+",年龄是："+age+"，我的体重是："+weight+“kg,性别是”+sex);
}
}

使用类构建对象
对象类型对象名称 = new 类名称();
Person p1 = new Person();

课堂作业： ketang0717 /lianxi01.java
创建一个Cat类，有名字、性别、年龄、颜色，
并且定义一个方法输出这些信息
public class lianxi01{
public static void main(String [] args){

            Cat c1 = new Cat();
            c1.name = "Mercy";
            c1.age = 7;
            c1.colour = "白色";
            c1.sex = "女";
            c1.Cat();
    }

}

    class Cat{
    String name;
    int age;
    String colour;
    String sex;

            public void Cat(){
            System.out.println("猫的名字是："+name+"，它今年"+age+
	"岁了，它的颜色是"+colour+",性别是："+sex);
            }

}

java面向对象语言：

1、什么是面向对象？
2、什么是面向过程？
3、编程语言的发展历史
人已分类这种方式认知世界（宇宙）
4、面向对象的开发：
1、定义类（分门别类的过程）

class 类名{
	//类的静态特征，属性
	数据类型 属性；

	//方法
	public void speak(){
		System.out.print("不知道说啥");
	}
}
2、得到对象
类型 对象名称 = new 类型();

//为属性赋值
对象名称.属性名称 = 属性值;


对象名称.方法名称([参数列表]);

课堂作业： lianxi02.java
请定义类矩形类（React），求面积和周长

自己写的↓
import java.util.Scanner;
public class lianxi02 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print(“请输入宽:”);
double a = sc.nextDouble();
System.out.print(“请输入长：”);
double b = sc.nextDouble();

            React r1 = new React();

            r1.mianji= a*b;
            r1.zhouchang = (a+b)*2;
            r1.React();
    }

}
class React{
double mianji;
double zhouchang;
public void React(){
System.out.println(“矩形的面积是：”+mianji+
“矩形的周长是：”+zhouchang);
}
}

课堂练习： lianxi03.java
定义一个点类，求两点距离
public class lianxi03 {
public static void main(String[] args) {
Point p1 = new Point();
p1.x=3;
p1.y=5;

            Point p2 = new Point();
            p2.x=5;
            p2.y=1;

            double distance = p1.getDistance(p2);
            System.out.println(distance);
    }

}

class Point {
double x;
double y;

    //求两点距离
//参数为什么使用Point对象，因为Point携带着它的属性和方法
    public double getDistance(Point p) {
    return  Math.sqrt((x-p.x)*(x-p.x)+(y-p.y)*(y-p.y));
    }

}

课后作业1： zuoye0717 /Test01.java
定义一个圆类（Circle），求圆的面积和周长
课后作业2： zuoye0717 /Test02.java
在不同培训中心，会感受到相同的环境和教学氛围，用类的思想输出中心信息
课后作业3：zuoye0717 /Test03.java
什么是类？
什么是对象？
类和对象的区别是什么？
如何定义一个类、类的属性和方法？
如何创建类的对象？
数据类型有哪两种？区别是什么？

课后作业4： zuoye0717 /Test04.java (面积公式有问题)
定义一个三角形类，计算三角形的周长和面积
课后作业5： zuoye0717 /Test05.java
定义一个Student类和Classroom类，列举常见属性和常见行为（学号名字学习行为）

课后作业6：zuoye0717 /Test06.java
完善用户登录注册将提示更加清晰
字符串用equals（）

UMI图：
类图
在main函数中定义的变量，生命周期和全局变量一致，但实际是局部变量

局部变量：
定义函数内部的变量，当函数调用完成，也就是函数弹栈后，局部变量会消失
全局变量：

成员变量：
成员变量定义在类中，属于对象或者类的
成员方法：
就是类中的方法，属于对象或者类

用户的登录和注册：：
用户要登录用户（User）
用户名称
用户密码
用户性别
用户昵称
用户有登录方法
注册方法

20190718 Day 7
作业讲解4： zuoye0717 /Test04.java
定义一个三角形类，计算三角形的周长和面积
public class Test04 {
public static void main(String[] args) {
Triangle t = new Triangle();
double x ;
double y ;
double z ;

            t.x =3;
            t.y =4;
            t.z =5;
            System.out.println(t.ZC());
            System.out.println(t.MJ());
    }

}
class Triangle{
double x;
double y;
double z;
public double ZC(){
return x+y+z;
}
public double MJ(){
double p = ZC() /2;
return Math.sqrt(p*(p-x)(p-y)(p-z));
}
}
~

eclipse的使用
1、属性的默认值问题
2、构造函数
3、this指针
4、对象的初始化 student classroom
5、static关键字

完成一个用户的登录注册
在main函数中，定义个数字（对象数组）
注册：
用户名称密码
构建一个User对象
再将这个对象存储数组中

1、属性的默认值问题
成员变量如果没有赋值，会自动的根据变量类型默认值
局部变量如果没有初始化，则无法使用，代码会报错
2、构造函数
为什么有构造函数：
初始化成员变量

public 类名称(){
	//构造函数
}

注意：
1、构造函数是用来初始化成员变量的
2、构造函数名称必须和类名称一致
3、构造函数不能写返回值*
4、我们通过类得到类型对象名称 = new 类型(); 类型()本质就是在调用构造函数
5、如果我们定义了一个类，没有构造函数，那么JVM会自动生成一个无参的构造函数
6、如果我们自定义了构造函数，JVM则不会自动生成无参的构造函数

内容回顾：
1、做一个用户登录的案例
2、变量的初始化问题
–成员变量
–局部变量
局部变量必须赋值才可使用
3、构造函数的使用
作用：初始化成员变量
如何定义构造函数
public 类名称([参数列表]) {
初始化成员变量;
}
1、构造函数必须名称和类名称保持一致
2、不能写返回值
3、如果定义了一个类，没有写构造函数，那么JVM会自动的生成一个构造函数(无参)
4、如果我们定义了构造函数，系统将不再生成无参的构造
以后定义java类，java bean，
一般构造函数会听到两个
一个无参构造一个全参构造
根据其他情况来定
4、this指针的使用（堆中）
在java类，存在一个this指针，该指针会自动在创建对应对象时，默认指向对象，
所以此时this就是这个对象

5、类的成员的初始化顺序：
	在初始化对象的时候，首先初始化的是属性，之后才是构造函数
	方法是在调用时才初始化的，调用完成后则出栈
6、static 关键字
	static是java的关键字
	被static修饰时的成员变量最先被加载到内存中
	被static修饰时的方法、变量都属于 类 本身，不属于对象，意味着可以直接通过类名来调用
	静态方法中不能直接调用非静态方法(加载顺序)
	被static修饰的变量存放在常量区的   也就是无法被回收的

7、面向对象的特性（封装、继承、多态）

课堂练习： /ketang0718/ TestClassroom.java
public class TestStudent{
public static void main(String[] args){
Student stu1 = new Student(“世羽梵”,18,“B16031220”);
System.out.println(stu1);
}

}
class Student{
String name;
int age;
String no;

    public Student(String name, int age,String no){
            this.name = name;
            this.age = age;
            this.no = no;
    }
    //重写toString方法
    //一般测试代码需要重写toString方法
    public String toString(){
            return "我的名字是"+this.name+",我今年"+this.age+"岁了，我的学号是"+this.no;
    }

}

课堂作业：
完成班级的定义： ketang0718/TestClassroom.java
public class TestClassroom{
public static void main(String[] args) {
Classroom cla1 = new Classroom(“欧鹏互联教室B”,7,50);
System.out.println(cla1);
}
}
class Classroom{
String name;
int num;
double since;

    public Classroom(String name,int num,double since){
            this.name = name;
            this.num = num;
            this.since = since;
    }
    public String toString(){
            return "教室名字是"+this.name+",教室数量是"+this.num+",教室大小是"+this.since+"平方米";
    }

}

匿名对象 TestClassroom

封装：
1、什么是封装
面向对象的编程中，封装就是指将类的属性私有化，提供公开的方法去访问的方式，叫做封装
2、怎么私有化属性？
权限访问修饰符（就是代码开头的东西 public(←) class xxxx ）

	public		//公开的 
	private		//私有的     被其修饰的，只允许在一个类中使用
	默认(不写)(缺省)  //只能同包、同类访问
	protected	//受保护级别 同包、同类、子类(继承)访问

3、如何实现封装
	将属性私有化，提供公开的方法去访问和设置值

	将属性私有化，通过private访问修饰符修饰
	之后提供公开的get和set方法来操作属性
4、一个标准的java bean（java类）书写规范
	private 修饰属性
	通过公共set和get方法来访问属性

	构造函数一般至少有两个，一个没有参数，一个全部参数

作业1：课堂代码练习
作业2：将用户管理熟练
作业3：尝试着将用户管理的属性私有化（使用封装的方式操作）
作业4：萌宠大作战

20190719 DAY 8
内容回顾：
4天讲解CentOS7
编程基础部分：5天
面向对象的编程：4天
类和对象
static
构造函数
构造函数的作用：初始化成员变量
this指针
类成员初始化的顺序：
在初始化对象的时候，首先初始化的是属性，之后才是构造函数
方法是在调用时才初始化的，调用完成后则出栈
面向对象的三大特征：封装、继承、多态
封装的定义：
将类的属性私有化，提供公开的get和set方法供外界访问或者设置的操作

类的成员：
成员变量
成员方法
构造方法

学习目标：
1、引用传递和传递
2、类的成员
静态代码块
构造代码块
3、eclipse的使用
4、包的使用
5、继承
6、多态
7、抽象类
8、接口

在类的成员：面试重点
成员变量
成员方法
构造函数
构造代码块
静态代码块
（被static修饰的最早被加载，且按照顺序走）
在类中，当初始化一个类的实例时，首先被加载的是静态代码块(若是静态属性的话，按照先后顺序走)，
之后是属性，下来是构造代码块，最后是构造函数

对象引用和值引用
垃圾回收机制

包的使用：
什么是包？就是文件夹
目的：方便管理java的类，防止类名冲突，管理项目

***命名规则:包一般以公司的域名倒着写***
com.baidu.项目名称.模块
如：com.baidu.yun.controller
com.openlab.user

强制规定：以后所有的类必须使用包
4、继承

Java是一门面向对象的语言，面向对象的语言有三大特征：封装，继承，多态
封装：将属性私有化private，提供公开的方法来访问的方式

继承：

当子类继承父类后，那么子类就自动的拥有了父类的一些方法和属性

继承规则：
	1、public修饰的 都能被继承
	2、protected修饰的可以被继承
	3、默认没写情况下，只有同包能访问

子类可以继承父类被public和protected修饰成员

练习：动物类（Animal类）
name
colour
age
xxx

info（介绍）

Dog、Cat

解析：
父类：
package com.openlab.java.day08;

public class Animal {
public static void main(String[] args){

}

public Animal(String name, String color, int age) {
	
	this.name = name;
	this.color = color;
	this.age = age;
}


 String name;
 String color;
 int age;

public String getName() {
	return name;
}

public void setName(String name) {
	this.name = name;
}

public String getColor() {
	return color;
}

public void setColor(String color) {
	this.color = color;
}

public int getAge() {
	return age;
}

public void setAge(int age) {
	this.age = age;
}	

public Animal(){
}

public void info(){
	System.out.println("我的名字是："+this.name+"，我有一身"
						+this.color+"颜色的毛，我今年"+this.age+"岁了");
}

}

子类：
package com.openlab.java.day08;

public class Cat extends Animal {

public static void main(String[] args) {
	Cat c = new Cat();
	c.setName("小黑");
	c.setColor("黄色");
	c.setAge(7);
	c.info();
}

}

1、在继承中，子类只能继承父类的被public或者protected修饰的方法或者属性
2、在父类方法不能满足子类的使用时，我们一般重写（覆盖）override方法
3、子类在构造的时候，首先调用了父类的构造，之后才调用自身的构造方法
4、super是一个指针，指向子类的父类，
	super();     //调用就是父类的构造
	super.xxx     //就是调用了父类的属性或者方法
5、java中不允许使用多继承,Java是单继承机制
	如果需要多继承机制，则使用接口解决
6、java中 所有类 都共有一个父类  Object

5、多态

20190721 Day 9
java se 的内容回顾：
day 1 ： java编程入门
编程语言的历史
java编程语言的历史
环境：
开发环境：文本编辑器
运行环境：安装jdk
下载jdk
配置jdk
window下配置
Linux下配置
第一个程序hello world
day 2 : 变量
常量
变量命名规则
常见的运算符
三大流程
顺序
选择
循环
day 3 :
switch
循环
day 4 :
函数
day 5 ：
数组
day 6 ：
面向对象
类和对象
如何定义类
静态特征属性
动态行为方法
day 7 :
构造函数
this指针（堆中）
封装
day 8 ：
static关键字
对象初始化问题
成员变量
成员方法
构造方法
static静态代码块
构造代码块
继承
extends

	重写是真正重写了父类方法吗
      答：不是

今日内容：

1、final 关键字
2、内部类
3、多态
4、抽象类
5、接口

final 关键字的使用
1、修饰变量，则该变量会变成常量(因为值不能再发生变化)
2、修饰方法，该方法不允许被重写(OverRide)，一旦一个方法被final修饰，这个方法就是最后的方法，无法被子类重写
3、修饰类，当final修饰类的时候，则类无法被继承，不能有子类
内部类：
类的内部定义叫做内部类
内部类的最大作用就是，访问包含他的类的私有属性和方法
public class TestStatic{
/*
定义一个常量
被final修饰的变量将不再发生变量，所以就变成了常量
*/
public static final int MAX = 10;

public static void main(String [] args){
//常量，不允许修改他的值
}

}

多态：
面对对象存在三大特性：封装、继承、多态

多态就是对象的多种状态
在面对对象中，多态指的是，父类引用指向子类实例的现象，叫做多态

父类引用指向子类的实例
	  此时可以使用父类来代替所有的子类

final关键字
变量---->常量
方法---->无法被子类修饰
类---->无法被继承

内部类：
定义在类内部的类
多态：
对象的多种状态
在继承的基础上，父类引用指向子类实例这种现象叫做多态

Animal animal = new Dog()；
animal.

宠物治病案例:

父类需要存在某个，但是实现不是必须的
主要是由子类来实现各自的功能！！！

抽象方法：没有实现的方法叫做抽象方法，abstract

1、如果某个类中，某个方法没有实现，则需要使用abstract 将该方法申明为抽象方法
2、一旦某个类中存在了抽象方法，该类必须申明为抽象类。
3、抽象类没办法直接实例化
4、子类一旦继承了抽象类，必须要实现抽象方法，如果没有实现，则必须将子类申明为抽象类，继续向下传递这种特性

抽象类中可以存在普通的方法？
可以
抽象类中可以没有抽象方法吗
可以

作业1：如下关键字组合修饰类，是否合法
private abstract X
static abstract X
final abstract X

答： private 是私有的，私有的不能被继承，而abstract必须要继承，本身不能实体化
static 修饰的是静态方法，或静态变量，定义的是类文件
final 一旦一个类被final修饰，该类不能被继承

多态的必要条件：
继承
方法重写

接口 interface
在Java中，可以使用interface关键字，声明的类叫做接口
注意：接口中的成员都必须是public，即便没有声明也是public，接口的所有成员都是公共的
接口中的方法都是抽象方法(接口中方法没有实现)
接口中不能有实现的方法（必须都是抽象方法，jdk1.8之前）
接口可以多个实现（implements TestInterface，MyInterface2）
（重点掌握）接口可以继承接口public interface MyInterface2 extends TestInterface
在jdk1.8之后

接口的作用：
1、约束、规定
2、对java单继承的补充(充当多继承)

接口和抽象类：
接口是一种特殊的抽象类

接口的命名规则：
接口包的命名规则：
一：第一种情况
1、将接口定义在包中 UserDao.java
2、接口的实现类一般放在该包的下一层 xxxx.impl UserDaoImpl.java
二：第二种情况
将接口和实现类放在一起
IUserManager
实现：UserManager

课堂作业：
定义一个接口
IUserManager
定义如下方法：
load(int id)
get(int id)
list()
delete(int id)
update(int id)
UserManager

答：
创建第一个包---->interface
package userManager;

public interface UserManager {

void	load(int id);
void	get(int id);
void	list();
void	delete(int id);
void	update(int id);

}

第二个包文件里面---->class 添加接口add UserManager
package userManager.impl;

import userManager.UserManager;

public class Iusermanager implements UserManager {

public void load(int id) {
	// TODO Auto-generated method stub
}
public void get(int id) {
	System.out.print("id is"+id);
}
public void list() {
	// TODO Auto-generated method stub
}
public void delete(int id) {
	// TODO Auto-generated method stub
}
public void update(int id) {
	// TODO Auto-generated method stub
}

}

20190722 Day 10
随机数：
Math.random() //该方法会返回一个[0,1)
0~10 (int) (Math.random()*10)
0~x (int) (Math.random()x)
x~y min + (int)(Math.random()(max - min))

Random类：
Random r = new Random();

r.nextInt(50); //0~50的随机数

50~500：50+r.nextInt(500-50);

20190723 Day 11
内容回顾：
昨天做一个面向对象的总结，以游戏案例
作业:完成一个用户管理案例（这周周末）

你们解决问题的方案：
1、自己思考（最重要的）
2、自己查文档（在线/离线文档，重要）
3、和同学讨论（也很重要）
4、问老师

今天内容：
Object类
异常
什么是异常
为什么存在异常
创建异常有哪些
异常的处理方案
如何定义异常
如何人为的抛出异常

Object：
在Java中，任何一个类，直接或者间接都是Object的子类

Object类定义在java.lang包

-------------跟线程相关方法，后面再说-----------------------
wait(); //让线程进入等待状态
notify(); //唤醒线程的方法
notifyAll(); //唤醒所有等待线程的方法

clone();    //做对象拷贝的
Class cls = getClass();   //获取当前对象的字节码文件
				在反射中需要使用这个
toString();
如果没有重写对象的toString方法，当我们直接打印对象的时候
package.ClassName@hashCode值

hashCode返回内存地址的hash值是十进制的
toString 作用：测试对象

面试题1：
请解释final finally finalize 三者的作用和区别
final 申明类的，
finally://一定执行的代码块
//不管是否存在异常，finally内的代码块一定会执行
//资源释放等工作在finally

finalize();  //是object提供的方法，该方法在对象被垃圾机制回收前，最后被触发
System.gc();  //手动调用垃圾回收机制

equals();    //比较两个对象是否相等
		equals方法底层真正比较的是两个对象的内存地址()
		public boolean equals(Object obj) {
			return (this == obj);
		}
//equals()
在String类，我们可以直接调用equals比较两个字符串，因为String类重写Object的equals方法

hashcode();  //返回对象的内存地址的哈希值

instanceof // 判断对象是不是所属类

最佳建议：
在编程中，一般比较对象，需要重写hashCode、equals

根据多态的特性：如果方法中参数是对象，可以使用Object类型

异常
1、什么是异常
定义：代码运行过程中，或者编译过程中，
因为用户的不当操作或者一些其他的因素干扰导致程序出错现象叫做异常
2、处理异常的目的
让程序继续运行，同时提醒用户
3、常见的异常
ArithmeticException(算术异常)
4、什么是异常
java中异常就是类
一旦代码出现了异常，程序就会被终止掉
5、java中处理异常的方式：
1. 不处理抛给调用者
2. 使用try catch 语句块尝试着去抓取异常

	try：
		//可能出现异常的代码

		(↓某某某异常 异常对象)
	catch(xxxException e){
		//当代码触发了异常，代码会进入到catch中
	}	//e是异常对象

6、异常对象中的两个方法
	//打印异常触发的栈信息
	e.printStrackTrace();

	//获取异常信息
	e.getMessage();
7、try catch 的运行流程

8、try catch finally 
	try{
	
	}catch(ArithmeticExceptong e){
	
	}finally{
		//一定执行的代码块
		//不管是否存在异常，finally内的代码块一定会执行
		//资源释放等工作在finally
	}

面试题2：在函数中，如果finally之前，遇到了return关键字，
代码如何执行？会直接返回还是执行完finally中的代码在返回？

内容回顾：
Object类：
java中默认任何类都继承Object这个类的
方法:
clone()
wait() 作用：让线程进入阻塞状态
notifyAll() 作用：唤醒所有进程
equals()
hashcode()
getClass()
toString()
面试题3：（扩展题）
为什么在比较对象的时候我们需要重写hashcode和我们的equals方法？

异常（Exception）
1、什么是异常
2、如何处理异常
捕获异常
抛出异常
3、捕获异常的操作
try{
//可能发生异常的代码

	}catch（XXXException e）{

		//异常发生时，需要执行的代码

	}finally{

		//必须执行的代码
	}
4、try语句块的顺序

5、常见的异常有哪些
	ArithmeticException
	NullPointException
	ClassCastException
	下标越界异常
	...

6、使用多个catch进行多次异常的捕获
	注意：当捕获到一个异常后，其他一次无法被捕获了

7、异常继承关系
	Throwable

8、异常抛出（throws关键字的使用）
	第二种处理异常的方式
	在方法的名称后面使用throws，抛出异常，将可能出现的异常抛给调用者	
	有调用者来处理异常，如果调用者也不处理异常，则继续向上抛，最后如果都不处理，则会有main函数抛给JVM

9、自定义异常的使用	
	当jdk提供的异常不够我们使用的时候，我们需要自己定义异常
	建议继承RuntimeException

10、异常类型：
	编译型异常：  在编译时，必须处理的异常 Exception
	非编译型异常： 在运行时，抛出的异常，RuntimeException 或者它的子类

11、人为抛出异常
	人为抛出异常，一般都是底层为高层传递信息

练习：按照控制台提示输入1～3之间任一个数字，程序将输出相应的课程名称
根据键盘输入进行判断。如果输入正确，输出对应课程名称。如果输入错误，给出错误提示
不管输入是否正确，均输出“欢迎提出建议”语句

package ketanglianxi;
import java.util.Scanner;
public class pptlianxi {
public static void main(String [] args){
System.out.print(“请输入课程代号(1~3之间的数字)：”);
Scanner input = new Scanner(System.in);
try{
int a = input.nextInt();
if(a == 1){
System.out.println(“C#编程”);

	}else if(a == 2){
		System.out.println("Java编程");
	
	}else if(a == 3){
		System.out.println("甲骨文");
		
	}else{
		throw new Exception();    //要抛出
	}
	}catch(Exception e){	
		System.out.println("请输入正确数字!");
		e.printStackTrace();
	}finally{
		System.out.print("欢迎提出意见：");
	}
}

}

20190725 Day 12
内容回顾（9:00-12:00 13:30-16:00）：
Object对象学习：
clone();
getClass();
wait();
notify();
notifyAll();
equals();
hashCode();

异常(Exception):保证代码的健壮性
	1、什么是异常
	2、几种常见异常的处理方式
	3、try 语句块流程
	4、异常的类型
	5、自定义异常
	6、异常的抛出throw关键字异常对象
	7、throws将异常抛给调用者

这几天目标：
1、聊一聊main函数的参数问题
2、包装类
3、字符串对象
4、StringBuilder和StringBuffer
5、日期和时间的相关操作
jdk8之前的
jdk的新特性
6、设计模式（单例、工厂）
7、BigInteger和BigDecimal
8、简单的排序方式
9、集合（list、set、map）

课堂案例：
在main函数中，通过参数来控制程序的运行
如输入1，则输出，你今天状态不错，继续保持
如输入1,2，则输入，你今日状态不行，请睡觉
如输入1 2 3，则输出，代码正常执行了
如没有参数，则提示用户，参数不正确

运行时 RUN AS–>Run Configreations来运行（改参数Arguments）
package com.openlab.Demo;

public class TestDemo {
public static void main(String[] args){

	if(args.length == 0){
		System.out.println("参数不正确，请输入正确的数字");
		
	}else if(args[0].equals("1") && args.length==1){
			System.out.println("你今天状态不错，继续保持");
		}else if (args.length==2 && args[0].equals("1") && args[1].equals("2")){
			System.out.println("你今日状态不行，请睡觉");
		}else if(args.length==2 && args[0].equals("1") && args[1].equals("2") && args[1].equals("3")){
			System.out.println("代码正常执行");
		}else{
			System.out.println("other");
		}
	}
}

“1234”—>1234数字

封装类（包装类）：
在java中，每一个java的基本数据类型都对应着一个对象
基本数据类型对象
int Interger
byte Byte
short Short
long Long
float Float
double Double
char Character
boolean Boolean

求两个数和的：(Run As—>Run Configurations 两个参数然后才能求和)
package com.openlab.Demo;

public class TestArgs2 {
public static void main(String[] args){
if(args.length !=2){
System.out.println(“输错啦！猪头”);
}else{
int num1=Integer.parseInt(args[0]);
int num2=Integer.parseInt(args[1]);
System.out.println(“和是”+(num1+num2));
}
}
}

作业1：将系统内置的8个包装类方法和属性都过一遍

字符串对象：
字符串不属于基本数据类型，看着字符的数组

char c = 'a';
char [] arr = {'a','b','c'};   //"abc"

Java中，字符串是对象，由系统定义 java.lang.String类
final修饰

一、字符串的定义：
1.最简单的定义
String str1 = “liujianhong”;
System.out.println(str1);

2.利用无参构造函数
String str2 = new String();
System.out.println(str2+"liujianhong");

3.有参数的构造方法
String str3 = new String("liujianhong");
System.out.println(str3);
/**
 * 注意字符串的字节数组的构造和字符数组的构造
 */

二、字符串的常见方法：
index下标从0开始
（索引↑）
1、查找字符在字符串中的第一个位置的索引→（.indexOf("…")）

int index = str.indexOf('o');
System.out.println(index);

输出： 8

2、查找字符在字符串中最后一个位置的索引→（.lastIndexOf("…")）

int li = str.lastIndexOf('o');
System.out.println(ln);

输出： 17

3、如果查询不到，返回值就为 -1
System.out.println(str.indexOf(“haha”));
输出： -1

4、通过下标，获取字符串对应下标的字符→（.charAt("…")）

System.out.println(str.charAt(5));
System.out.println(str.charAt(5));

输出： a

5、比较字符串是否相等，严格比较→（.equals("…")）

System.out.println(str.equals("12345"));
System.out.println("AdbcdE".equals("aDBcDe"));

6、忽略大小写，比较内容 →（.equalsIgnoreCase("…")）

System.out.println("AdbcdE".equalsIgnoreCase("aDBcDe"));

7*、去掉两边的空格 →（.trim()）

System.out.println(" asdfsdf asdfasdfasdfasf ".trim());

8、判断某个字符是否在该字符串中→（.contains("…")）
System.out.println(str.contains(“jianhong”));

测试这个字符串是否以指定的前缀开始→（.startsWith("…")）
System.out.println(str.startsWith(“liu”));

测试如果这个字符串以指定的后缀结束→（.endsWith("…")）
System.out.println(str.endsWith(“man!!!”));
输出都为 true

9、获取字节数组→（.getBytes()）
byte[] bytes = str.getBytes();

10、替换→（.replace()）
String newStr = str.replace(“某个字符(旧)”, “新字符替代前面的旧字符”);
如：String str = “liujianhong is good man!!!”;
String newStr = str.replace(“is”, “zrbb”);
输出：liujianhong zrbb good man!!!

11、通过特定的符号分割字符串，返回值是数组→（.split(" “)）
public class lianxi {
public static void main(String [] args){
String str = “liujianhong is good man!!!”;
String[] split = str.split(” ");
for (int i = 0; i < split.length; i++) {
System.out.println(split[i]);
输出：
liujianhong
is
good
man!!!

12、切割字符串→（.substring()）

String str = “liujianhong is good man!!!”;

// 第一个参数，表示开始截取的小标，如果没有第二个参数如果下标为负数，则报错
// z则表示截取到末尾
String string = str.substring(3);
System.out.println(string);
输出：jianhong is good man!!!

String str7 = str.substring(3, 13);
System.out.println(str7);
输出：jianhong i

13、连接字符串有两种方案（+）（.concat()）
//+
String str1 = “刘建宏是个大帅哥”;
String str2 = “当然，我从来都是这样认为的”;
System.out.println(str1 + str2);

// 官方提供用来拼接字符串的方法
System.out.println(str11.concat(str12));

14、在java中拼接字符串，使用StringBuilder或者StringBuffer来完成拼接
StringBuilder sb = new StringBuilder("");
StringBuffer sb = new StringBuffer("");
for (int i = 0; i < 100; i++) {
sb.append(i);
}
System.out.println(sb.toString());

	/**
	 * StringBuilder效率比StringBuffer高，但是
	 * StringBuffer线程安全
	 * StringBuilder非线程安全
	 */

内容回顾：
1、main函数的参数问题
2、包装类（封装类）的使用
int Integer
byte Byte
short Short
long Long
float Float
double Double
char Character
boolean Boolean

3、字符串对象
	1. 字符串的定义
	2. 字符对象的常见方法的学习
		indexOf()
		LastIndexOf()
		charAt()
		length()
		trim()  去空格的
		equals()
		equalsIgnoreCase()
		toLowerCase()
		toUpperCase()
		split()

作业2：
将字符串（String）的所有方法都一遍

字符串的内存结构

字符串是常量，常驻内存，每个字符串都只能一份
在java中拼接字符串，使用StringBuilder或者StringBuffer来完成拼接
StringBuilder比StringBuffer效率高但是
StringBuffer线程安全
StringBuiler非线程安全
作业3：请简述String、StringBuilder、StringBuffer之间的区别
String会常驻内存，所以提供了

20190725 Day 13
内容回顾：
String对象知识
main函数
包装类（封装类）
装箱
拆箱

	int a = 10;
	Integer aa = new Integer(a); //装箱操作
	a = aa.intValue();	//拆箱操作
	jdk1.5之后完成自动拆装箱
	Interger aa = a;
	int b = aa;
	转换类型的方法
	Interger.parseInt("123");
String对象的学习：
	String s = "liujianhong";
	String ss = new String();
	// 常见方法：
	contain()  //查询字符串中是否包含某个字符
	indexOf()  //查询某个字符串在该字符串中的首个索引位置
	lastIndexOf()  //最后一个
	endsWith()  //查询是否以...为后缀
	trim()  //去除字符串两边的空格位
	substring() //切割字符串
	startsWith()  //以xx开始
	replace()  //替代
	join()
	equals()
	split()
	length()
	StringBuilder 
	StringBuffer
	操作拼接

1、时间日期格式化（早上）
2、堆栈问题
3、位移运算（计算机底层二进制运行原理）
4、BigInteger和BigDecimal
5、设计模式（单列、工厂）
6、常见的几种排序方式
7、集合

面试题：
字符串存储的位置问题？
字符串存储在运行时常量池中

在jdk1.8之前 字符串存储在 方法区（method area），方法区一般是存储常量的地方
在jdk1.8及其以后，字符串存储在 堆中

时间对象的重要性，java中如何对时间进行操作
Date（日期）
Calendar（日历）在jdk低版本中，一般操作时间使用Calendar
SimpleDateFormat

如上的对象，在操作时间和日期时，如果处于高并发，都有可能出现线程安全问题。所以
jdk8.0之后，提供了其他替代的方案

获取系统时间： *
Date date = new Date(); *
System.out.println(date); *
*
//获取date时间的时间戳 date.getTime() *
System.out.println(date.getTime()); *
*
//通果System类获取 .currentTimeMillis() *
System.out.println(System.currentTimeMillis()); *
*
//获取当前时间的纳秒数 .nanoTime() *
//注意：不是时间戳，也不是1970开始 *
//跟电脑CPU、JVM相关的一个纳秒数 *
System.out.println(System.nanoTime()); *
*
格式化日期SimpleDateFormat *
//y – year 年 *
//M – month 月 *
//d – day 日 *
//h – hour 12小时制 *
//H – hour 24小时制 *
//m – minute 分 *
//s – second 秒 *****************************
//SimpleDateFormat sss = new SimpleDateFormat(“Gyyyy年MM月dd日 HH：mm：ss”);*
//G – 公元 *
//SimpleDateFormat 会将日期格式化为我们想要的格式的字符串 *
import java.text.SimpleDateFormat *
SimpleDateFormat xxx = new SimpleDateFormat(“yyyy-MM-dd HH：mm：ss”); *
String xxxDate = xxx.format(date); *
System.out.println(xxxDate); *
*
//如何获取对应时间 *
//在jdk1.8及其以后，直接使用Date获取特定时间已经过时了 *
Date d2 = new Date(2018,3,26,18,23,12); *
*
//日历对象的获取 .getInstance() *
//Calendar对象使用单例模式，不能通过new 关键字得到对象 *
Calendar cal = Calendar.getInstance(); ***************************
*
//获取当前时间 .getTime() *
System.out.println(cal.getTime()); *
*
//常见日历的方法 *
*
//构造一个想要的时间 *
cal.set(2018,8,3); *
System.out.println(cal.getTime()); *
*
//获取年 .getWeekYear() *
System.out.println(cal.getWeekYear()); *
*
//获取年份 .get(Calendar.YEAR) *
System.out.println(cal.get(Calendar.YEAR)); *
**********
//获取月份(因为外国是从0开始计算的) .get(Calendar.MONTH)+1 *
System.out.println(cal.get(Calendar.MONTH)+1); **********
*
//获取日期 .get(Calendar.DATE) *
System.out.println(cal.get(Calendar.DATE)); *
*
//获取小时 12小时制 .get(Calendar.HOUR) *
System.out.println(cal.get(Calendar.HOUR); *
*
//获取小时 24小时制 .get(Calendar.HOUT_OF_DAY) *
System.out.println(cal.get(Calendar.HOUT_OF_DAY));*
*******
//获取分 .get(Calendar.MINUTE *
System.out.println(cal.get(Calendar.MINUTE);*
*
//获取秒 .get(Calendar.SECOND) *
System.out.println(cal.get(Calendar.SECOND);*

作业1：
当时接口中的定义
static方法和default方法

static方法和属性属于类的，可以直接调用属性和方法
static 方法不能被继承 default方法可以被继承

// LocalDate获取当前日期，使用now
LocalDate now = LocalDate.now();
System.out.println(now);

//使用系统内置的格式
String format = now.format(DateTimeFormatter.ISO_DATE);
System.out.println(format);

//自定义格式
String format2 = now.format(DateTimeFormatter.ofpattern(“yyy年MM月dd日”));
System.out.print(format2);

//如果要操作时间
LocalTime lt = LocalTime.now();
System.out.println(lt);
/*
格式化也和LocalDate一致
*/
System.out.println(lt.format(DateTimeFormatter.ISO_LOCAL_TIME));

//LocatDateTime
LocalDateTime ldt = LocalDateTime.now();
System.out.println(ldt);
输出：2019-07-2611:43:16.600

System.out.println(ldt.format(DateTimeFormatter.ofpattern(“Gyyyy-MM-dd HH:mm:ss”)));

//Instant 获取得是UTC标准时间(伦敦时间)咱们比伦敦快8小时
Instant instant = Instant.now();
System.out.println(instant);

要求:掌握1.8之前的三个类 Date Calendar SimpleDateFormat
掌握1.8：LocalDate LocalTime LocalDateTime Instant DateTimeFormatter

int myMoney1 = 50;
double my Money2 = 12000.56;

//格式化数字，将数字格式化为000,000,000
NumberFormat format = NumberFormat.getInstance();
System.out.println(format.format(myMoney));
System.out.println(format.format(myMoney2));

//货币格式化
//默认使用的格式化风格跟系统相关
//如果要指定格式化风格，则需要使用java.util.Local类指定
NumberFormat format2 = Numberformat.getCurrencyInstance(Locale.CHINA);
NumberFormat format3= Numberformat.getCurrencyInstance(Locale.US);
System.out.println(format2.format(myMoney));
System.out.println(format2.format(myMoney2));

System.out.println(format3.format(myMoney));
System.out.println(format3.format(myMoney3));

//百分比的使用
NumberFormat format4 = Numberformat.getPercentInstance();
System.out.println(format4.format(0.58));

作业2：

NumberFormat和DecimalFormat
NumberFormat：
	数字的格式化
	货币的格式化
	百分比的格式化

DecimalFormat 参考PPT

常见的设计模式：
GOLF提出23设计模式，企业级开发架构而言，
单例(Singleton):单个实例，只能有一个对象，不能出现多个对象

懒汉模式：
public class User{
public static User user;
//首先将构造函数私有
private User(){
}
public static User getInstance(){
if(user == null){
user = new User();
return user;
}
return user;
}
}

饿汉模式:
public class User{
public static User user = new User();
//首先将构造函数私有
private User(){
}
public static User getInstance(){
return user;
}
}

工厂设计模式：
简单工厂
对象的创建交给一个工厂，由工厂统一管理对象的创建

位运算：
二进制
原码
补码
反码
位运算
int a = 8

a>>2   输出： 2   8/(2*2)
a<<2   输出：32  8*(2*2)                左移多少位=乘以2的多少次方

补充：
与或非运算
与运算 3&5 //一者为假，则为假（两者同真，则为真）
或运算 5|2 //只要一者为真，则为真
异或运算3^5 //两者相反则为真

堆和栈：
局部变量在函数里，函数在栈中，所以局部变量在栈中，成员变量在堆中

递归：函数自身调用自身

作业3：使用递归完成1~10的积

堆和栈：
java -Xss //指定栈大小
-Xms //堆的初始化大小
-Xmx //堆的最大值

20190727 Day 14
内容回顾：
1、时间和日期对象
以jdk1.7之前：Date、Calender、SimpleDateFormat对象格式化日期
jdk7之后：LocalDate、LocalTime、LocalDateTime、DateTimeFormatter、Instant、
2、堆和栈
-Xss //调整JVM栈大小
-Xms //调整JVM堆的初始化值
-Xmx //调整JVM堆的最大值
3、递归：
函数自身调用自身
特点：往复调用
本质：死循环
构成递归条件：1. 函数自身要调用自身
2. 终止条件
4、NumberFormat 数字格式化
数字格式化
货币格式化
百分比格式化
5、计算机底层运算
计算值以二进制的补码运行的
原码
反码
补码
位运算
无符号右移
有符号右移
左移
与运算&
或运算|
异或运算^
6、设计模式
单例设计模式
饿汉模式
懒汉模式
简单工厂设计模式
7、BigIngeter和BigDecimal
8、常见几种排序（冒泡、选择、插入）

今日目标：
集合（Collection）

对于大量数据的操作：
1、数组操作
数组中只能存储一种数据类型
一般数组的大小是固定的
连续内存
访问速度快
增删改比较麻烦

java中集合(Collection)都是定义在util包中的
接口都是在Collection中发挥作用（List、Ste、Map）
Map 没有继承Collection 而是依赖于他
Iterator迭代器
List下的类：ArrayList LinkedList
Set下的类：HashSet
Map下的类：HashMap TreeMap

List 链表：
可以存储任何数据
add方法，会将该对象存储到List最后位置
可以存储不同类型
list可以存储相同的值
List 链表：
ArrayList
基于数组实现的链表
查询速度快
更新速度慢
ArrayList 如何添加数据过程：
ArrayList默认大小是10
Object[] aa = new Object[MAX_SIZE];
size
aa.add(5);
在ArrayList添加数据的过程：
判断插入是否已经大于等于数组长度，如果已经成立，需要扩容，默认初始大小10
每次扩容为原有的1.5倍，扩容完成
在进行数据的插入
面试题：ArrayList和LinkedList的区别：
ArrayList 是连续数据
ArrayList查询速度快,增删改速度比较慢，
LinkedList查询速度慢,增删改速度比较快
LinkedList是典型的双向链表

泛型：
强制规定：在以后使用集合，必须使用泛型

早晨内容：
集合（Collection）
5个接口：Interable(可迭代对象)、Collection、List、Set、Map
5个类：ArrayList、LinkedList

Iterator Iterable
迭代器可迭代对象

使用迭代器完成数据的迭代
在java中，实现了iterable这个接口的类都默是可以被迭代的对象
存在一个iterator方法，返回一个迭代器对象

Set（集合）：
两大特点：
无序
不能重复,当Map中key相同时，规则覆盖有关值

Map（二维表）：
（ps = 200;addr = 100000;age = 1000；username = 2）

Map结构：
jdk1.8之前：
数组+链表组成
jdk8及其以后：
数组+红黑树的实现
链表

面试题：
1、map put数据的过程

2、Java map的底层实现

案例作业：
用户管理
User UserManger
IUserManger

User  load(int id);
User  load(String username);
void add(User user);
void dekete(int id);
void update(User user);
void login(User user);
List<User> list();

20190729 Day 15
周作业（视频）：下周一收（7号收），面向对象
class开头的
home开头的
team开头的
用户管理（数组、集合）

内容回顾：
集合，java为我们提供的容器的使用
Collection接口继承了 Iteartable接口
→ List接口（线性表）
Collection接口下有 → Set接口（集合）
→ Map接口（二维表）

List
    ArrayList  基于数组组实现的线性表
    Vector 向量
    ---------------------------------

面试题：ArrayList和Vector都是数组实现的线性表，一般情况下用ArrayList，
因为效率原因。ArrayList的效率要远高于Vextor，ArratList是线程不安全的，Vector是线程安全

    LinkedList 基于双向链表的实现

 Set
	HashSet
		无序，不能重复
Map	
	二维表
	HashMap
	TreeMap
	......
	Map的key可以试任意类型（包括null），只是一般使用String

面试题：
HashMap的put过程：
1.8之前，HashMap底层结构是一个数组+链表的实现
默认数组大小是16，负载因子是0.75
put第一步是：
对key进行hash算法，如果key为空，返回0，
若key不为空，首先获取key的hashCode值，再将该值有符号右移16位，
对两个值做异或运算，将结果返回
第二步：
判断是否需要扩容，如果需要则扩容
匹配对应的key，进入相应的桶，判断是否存在该key，若存在则覆盖；否则插入数据
再次判断需要则扩容

1.8及以后，HashMap底层实现数组+链表+红黑树的实现
		（红黑树和链表只能存在一个）
	当一个桶中插入的数据<8时，1.8之前一模一样， 是 数组+链表
	当一个桶中插入的数据>=8时，链表转为一个红黑树（数组+红黑树）

面试题： HashMap和HashTable的区别？

  HashMap线程不安全的，HashTable是线程安全的
  HashMap不允许null值，HashTable允许null值
  HashMap继承Dictionary类，HashTable实现Map接口

今日目标：
Collections类

IO流
     File对象，文件对象的操作
	//将后面的所有元素添加到list中去
	Collections.addAll(list,1,2,3,4,5,123,0,-50,12312,23,2);
	syso(list);

	//排序
	Collections.sort(list);
	syso(list);

	//使用二分查找查询元素,二分查找必须是有序的，所以先  排序  查找（要先排序）
	syso(Collections.bianarySearch(list,5));

	
	//随机排序
	Collections.shuffle(list);
	syso(list);

	//通过下标交互对应的数据
	Collection.swap(list,4,1);

	//将集合中元素顺序翻转
	Collection.reverse(list);
	syso(list);

	List<User> users = new ArrayList<User>();
	
	Collections.addAll(users, new User(1, "zs", "张三", "男"),
							  new User(4, "zhaoliu", "老六", "男"),
							  new User(2, "lisi", "历史", "男"),
							  new User(3, "wwlisi", "dadao", "男")
							  );
	System.out.println(users);

*//要比较对象，该对象必须实现Comparable接口
// 重写排序规则
// Collections.sort(users);
// System.out.println(users);

	Collections.sort(users, new UserByName());

// System.out.println(users);

	// 使用匿名内部类实现接口
	Collections.sort(users, new Comparator<User>() {
		@Override
		public int compare(User o1, User o2) {
			return o1.getNickname().compareTo(o2.getNickname());
		}
	});
}

}

//使用内部类实现新的排序规则
class UserByName implements Comparator {
@Override
public int compare(User o1, User o2) {
return o1.getName().compareTo(o2.getName());
}
}

class User implements Comparable {

private int id;
private String name;
private String nickname;
private String sex;

public int getId() {
	return id;
}
public void setId(int id) {
	this.id = id;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public String getNickname() {
	return nickname;
}
public void setNickname(String nickname) {
	this.nickname = nickname;
}
public String getSex() {
	return sex;
}
public void setSex(String sex) {
	this.sex = sex;
}

public User() {
}

public User(int id, String name, String nickname, String sex) {
	super();
	this.id = id;
	this.name = name;
	this.nickname = nickname;
	this.sex = sex;
}
@Override
public String toString() {
	return "id=" + id ;
}

/**
 *  要进行对象的比较，必须实现这个方法
 */
@Override
public int compareTo(User o) {
	// 由程序员自己定义规则
	if (this.id > o.id)
		return 1;
	else if (this.id < o.id)
		return -1;
	else
		return 0;
}

}

早晨内容回顾：
Collection类的使用，Arrays类很像
课堂作业：
Map完成
Map<String,List>

20190730 Day 16
内容回顾：
1、首先对集合进行了收尾（本质：数据结构的操作）
2、Collections类，专门用来操作集合的，都是静态方法
addAll
sort（Collection） //对集合进行排序，如果是自定义的对象，必须实现Comparable接口，实现他的compare
sort(Collection,Comparetor) //指重新制定排序规则，使用Comparetor接口，重写compare方法
二分查找 binarySearch
shuffle
swap
reverse
3、Arrays类，专门用来操作数组的
4、使用集合完成用户管理的练习
数组
Map 使用控制台进行控制

今日内容：IO流
1、File对象的使用
创建文件、目录
删除文件、目录
查询文件、目录
判断是文件、目录
遍历文件

1、File 对象
首先要导入java.io.File包
在window系统上，字符串中\ 表示一个 /
/ 也可以

课堂练习：
第一问：创建一个文件目录，并得到该文件的大小
第二问：使用File对象过滤特定后缀名的文件
第三问：遍历磁盘，将所有文件的名称（绝对路径）打印到控制台
一、二问：
package com.openlab.day16;
import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
public class TestFile {
public static void main(String[] args) throws IOException {
//第一问:创建一个文件目录，并得到该文件的大小
try {
File f1 = new File(“D:/zhang/rui/bin”);
f1.mkdirs();
System.out.println(f1.getTotalSpace());

	//第二问:使用File对象过滤特定后缀名的文件
	File f2 = new File("D:/zhang/rui/bin");	
	String[] list = f2.list(new FilenameFilter() {
		public boolean accept(File dir, String name) {
			if (name.toLowerCase().endsWith("txt")) {
				return true;
			} else {
				return false;
			}
		}
	});
	for (String s: list) {
		System.out.println(s);
	}	
} catch (Exception e) {
	e.printStackTrace();
}	
}

}
//第三问：遍历磁盘，将所有文件的名称（绝对路径）打印到控制台
public static void main(String[] args) {

	String path = "D:/";
	TestFiles(path);
}

	public static void TestFiles(String path){
		File file = new File(path);
		File[] files = file.listFiles();
		if(files != null){
		for(File f: files){
			if(f.isFile()){
				System.out.println(f.getAbsolutePath());
			}else{
				TestFiles(f.getAbsolutePath());	
			}
		}		
	}
}

}
2、IO流的分类，一个简单的FileInputStream的案例，说明流使用的步骤
流的分类
通过流的方法：
输入流字节输入流，默认都继承InputStream类.字符输入流，Reader
输出流字节输出流，默认都继承OutputStream类.字符输出流，Writer
按照功能划分：
节点流直接使用new关键字得到对象的流
过滤流（装饰流）过滤流主要用于装饰节点流，
根据流的数据类型：
字节流
字符流
转换流
lass TestIO {
/**
* 以后所有字节流都要如下操作
*/
@Test
void test01() {
写的步骤：1234步 //一、获取输入流对象
第 1 步： InputStream is = null;
try {
第 2 步： is = new FileInputStream(new File("E:/xx/xx));
第 3 步：第2步捕获异常↑
第 4 步：//二、定义一个字节数组
byte[] buf = new byte[1024];
第 5 步：//三、定义一个int类型长度
int len = 0;
第 6 步：//四、循环读取
while((len = is.read(buf)) > -1) {
(-1表示如果没读尽继续读)
第 7 步：第6步捕获异常↑
第 8 步：//五、使用标准输出流输出到控制台
//System.out.write(buf);（不关闭的话就要刷新一次）
//从字节数组中读取数据从0开始读，读len个长度
第 9 步： System.out.write(buf, 0, len);
}
（第3步生成的异常）： } catch (FileNotFoundException e) {
e.printStackTrace();
（第7步生成的异常）： } catch (IOException e) {
e.printStackTrace();
第 10 步： } finally {
// 必须执行
// 6、关闭打开的流！！！（倒着关闭）
if (is != null) {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

}
输入流和输出流
字节流和字符流
节点流和过滤流（装饰流）
转换流

3、文件输入输出流的使用（文件的复制和拷贝）
4、节点流和过滤流，案例拷贝数据，演示没有关闭流出现的问题，讲解装饰者设计模式的使用
5、DateInputStream DateOutputStream演示保存字节对象
6、字符流(Reader和Writer)
7、转换流（InputStreamReader和OubputStreamReader）

内容回顾：
File类
文件对象，java用来封装文件的
File f = new File(String path);
File f = new File(String parent,String filename);
File f = new File(File parent,String filename);
File f = new File(Uri url);

f.createNewFile();  //创建文件或文件夹
f.mkdir()	//常见目录
f.mkdirs()	//递归创建多级目录
f.exists()	//是否存在
f.existsOnExit()	//是否存在并退出
f.delete()	//删除
f.getAbsolutePath()	//获取f对象的绝对路径
f.getName()	//获取文件名称
f.getParent()	//获取父级路径
f.getFreeSpace()	//获取剩余空间
f.getUsableSpace()	//获取可用空间
f.getTotalSpace()	//总空间大小
f.getParentFile()	//获取父级File对象
f.renameTo()	//重命名或移动文件

f.isFile()	//是否是文件
f.isDirectory	//是否是文件夹(目录)

f.list()	返回的是文件对象的数组
f.list(FilenameFilter ff)	
f.listFiles()
f.listFiles(FilenameFilterff)

System.exit(0);//停止程序，让JVM机停止工作

装饰流(过滤流) Buffer 是它的一个子类
package com.openlab.day16;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;

public class TestZuoye {
public static void main(String[] args) {
BufferedInputStream bis = null;
InputStream is = null;
BufferedOutputStream bos = null;
FileOutputStream fos = null;
try {
is = new FileInputStream(“D:\eclipsedaima\day15 0729\src\com\openlab\day15\User.java”);
bis = new BufferedInputStream(is);
fos = new FileOutputStream(“D:\b.txt”);
bos = new BufferedOutputStream(fos);
byte[] buf = new byte[1024];
int len = 0;
while((len = bis.read(buf)) > -1){
bos.write(buf, 0, len);
}
//手动将最后一次的数据刷新
//bos.flush();
} catch (Exception e) {
e.printStackTrace();
}finally{
if(bos != null){
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
if(bis != null){
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

}

王山而3611

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

2019年7月总结

20190710 DAY 1 Java se: 1、linux（重要性） 2、Jave se： Jave基础部分 Java面向对象部分 Java高级特性

软件和课件的准备工作 在java基础部分，要求如下（动手）： 程序以动手为主（先写会，再问为什么） wwwh（what why when\where how） 先抄老师的代码 window开发代码为辅 在linux下使用vim工具进行java

所以咱们的学习以jdk8为主。

linux： 下午 jdk、jre

1、java语言的特点： 1、开放的 2、开源的 3、分布式 4、面向对象的 5、跨平台的（sum公司为大家提供不同平台的虚拟机JVM）

public class bianliang { public static void main (String [] args) { //定义变量 a //定义了一个变量a，类型是整数,值是10 int a = 10 ; System.out.println(a); //定义一个变量b，类型是int int b; //给变量b 赋值30 b = 30; System.out.println(b); } }

public class Test05 { public static void main(String [] args) { byte a = 10; int b = 20; int c = a + b ;//正确 //int c = a + b ; //正确 //byte c = (a+b);//错误 byte d =(byte)(a+b); //System.out.println(b);//错误 应该给高级别的c赋值输出，因为int>byte System.out.println(d); } }

作业：求出你的名字的Unicode码。 答： 张瑞斌 [zhangruibin@zhangruibin javazuoye]$ vim mianshiti.java [zhangruibin@zhangruibin javazuoye]$ javac mianshiti.java [zhangruibin@zhangruibin javazuoye]$ java mianshiti 张： 24352 24352 瑞： 29790 29790 斌： 25996

} 底层原因是因为前加加（前减减）优先级别很高 后加加（后减减）优先级别很低

选择结构： if if else if else if else switch

总结： 描述几种分支结构的语法和执行过程？ 什么情况下会使用多重if选择结构？ 多重if选择结构和switch选择结构的区别和适用场合是什么？

}

}

}

作业2：将昨天打印*的代码封装成函数 作业3：100~1000范围内，能同时被5和6整除的数 zuoye03.java 作业4：计算PI zuoye04.java 作业5：文档中题以每天10道的速度完成（超纲的除外） 1~9题写完

函数名([实参列表])； //函数的调用 函数的返回值 函数的参数 函数重载（overload） 同名函数 看类型和个数，不看型参 函数的递归（暂时不讲）

作业讲解： 1、请在控制台上输入两个数，并输入一个符号（±*/%） 定义五个函数 zuoye01.java 2、100~1000内，同时能被5和6整除的数 zuoye03.java

}

}

}

课后作业6：zuoye0717 /Test06.java 完善用户登录注册将提示更加清晰 字符串用equals（）

用户的登录和注册：： 用户要登录 用户（User） 用户名称 用户密码 用户性别 用户昵称 用户有登录方法 注册方法

eclipse的使用 1、属性的默认值问题 2、构造函数 3、this指针 4、对象的初始化 student classroom 5、static关键字

完成一个用户的登录注册 在main函数中，定义个数字（对象数组） 注册： 用户名称 密码 构建一个User对象 再将这个对象存储数组中

匿名对象 TestClassroom

作业1：课堂代码练习 作业2：将用户管理熟练 作业3：尝试着将用户管理的属性私有化（使用封装的方式操作） 作业4：萌宠大作战

类的成员： 成员变量 成员方法 构造方法

学习目标： 1、引用传递和传递 2、类的成员 静态代码块 构造代码块 3、eclipse的使用 4、包的使用 5、继承 6、多态 7、抽象类 8、接口

对象引用和值引用 垃圾回收机制

强制规定：以后所有的类必须使用包 4、继承

5、多态

1、final 关键字 2、内部类 3、多态 4、抽象类 5、接口

final关键字 变量---->常量 方法---->无法被子类修饰 类---->无法被继承

Animal animal = new Dog()； animal.

答： private 是私有的，私有的不能被继承，而abstract必须要继承，本身不能实体化 static 修饰的是静态方法，或静态变量，定义的是类文件 final 一旦一个类被final修饰，该类不能被继承

多态的必要条件： 继承 方法重写

}

20190723 Day 11 内容回顾： 昨天做一个面向对象的总结，以游戏案例 作业:完成一个用户管理案例（这周周末）

你们解决问题的方案： 1、自己思考 （最重要的） 2、自己查文档（在线/离线文档，重要） 3、和同学讨论 （也很重要） 4、问老师

今天内容： Object类 异常 什么是异常 为什么存在异常 创建异常有哪些 异常的处理方案 如何定义异常 如何人为的抛出异常

-------------跟线程相关方法，后面再说----------------------- wait(); //让线程进入等待状态 notify(); //唤醒线程的方法 notifyAll(); //唤醒所有等待线程的方法

最佳建议： 在编程中，一般比较对象，需要重写hashCode、equals