首页 文章 精选 留言 我的

精选列表

搜索[techo day],共2891篇文章
优秀的个人博客,低调大师

微服务架构Day34-Dubbo之跨域问题

Nginx概念 Nginx是一款高性能的HTTP服务器,反向代理服务器及电子邮件(IMAP/POPP3)代理服务器.由俄罗斯的Igor Sysoev所开发,Nginx能够支撑5万并发链接,并且CPU,内存等资源消耗非常低,运行非常稳定 Nginx应用场景 HTTP服务器,虚拟主机: Nginx是一个HTTP服务可以独立提供HTTP服务,可以做网页静态服务器,可以实现在一台服务器上虚拟出多个网站,例如个人网站使用的虚拟主机 反向代理: 当网站的访问量达到一定程度后,单台服务器不能满足用户请求时,需要用多台服务器集群时可以使用Nginx做反向代理 负载均衡: 多台服务器可以平均分担负载,不会因为某台服务器负载高宕机而某台服务器闲置的情况 HTTP服务器,虚拟主机 使用Docker安装运行Nginx,在./conf 里创建nginx.conf文件,配置docker-compose.yml version: '3.1' services: nginx: restart: always image: nginx container_name: nginx ports: - 80:80 volumes: - ./conf/nginx.conf:/etc/nginx/nginx.conf - ./wwwroot:/usr/share/nginx/wwwroot 虚拟主机: 虚拟主机是一种特殊的软硬件技术.可以将网络上每一台计算机分成多个虚拟主机,每个虚拟主机可以独立对外提供www服务,这样就能实现一台主机对外提供多个web服务,每个虚拟主机之间是独立的,互不影响的 通过Nginx可以实现虚拟主机的配置,Nginx支持三种类型的虚拟主机的配置: 基于IP的虚拟主机 基于域名的虚拟主机 基于端口的虚拟主机 Nginx配置文件结构: 其中每个server就是一个主机 events { } http { server{ } server{ } } 基于域名的虚拟主机配置 需求: 两个域名指向同一台Nginx服务器,用户访问不同的域名显示不同的网页内容 两个域名是admin.service.itoken.oxford.com和admin.web.itoken.oxford.com Nginx服务器使用虚拟机192.168.32.255 配置 Windows Hosts文件: 修改window的hosts文件(C:/Windows/System32/drivers/etc)-SwitchHosts 通过host文件指定admin.service.itoken.oxford.com和admin.web.itoken.oxford.com对应192.168.32.255虚拟机 创建目录及文件: 在 /usr/local/docker/nginx/wwwroot目录下创建htmlservice和htmlweb两个目录,并分别创建index.html文件 配置虚拟主机: 修改 /usr/local/docker/nginx/conf目录下的nginx.conf配置文件 user nginx; worker_processes 1; events { worker_connections 1024; } http{ include mime.type; default_type application/octet-stream; sendfile on; keepalive_timeout 65; server{ listen 80; server_name admin.service.itoken.oxford.com # 所有的请求都是以 / 开始,所有的请求都可以匹配此location location / { root /usr/local/docker/nginx/wwwroot/htmlservice; # 指定欢迎页面,按从左到右顺序查找 index index.html index.htm; } } server{ listen 80; server_name admin.web.itoken.oxford.com location / { root /usr/share/nginx/wwwroot/htmlweb; index index.html index.htm; } } } 基于端口的虚拟主机配置 需求: Nginx对外提供80和8080两个端口监听服务 请求80端口则请求html80目录下的html 请求8080端口则请求html8080目录下的html 创建目录及文件: 在 /usr/local/docker/nginx/wwwroot目录下创建html80和html8080两个目录,并分别创建两个index.html文件 配置虚拟主机: 修改 /usr/local/docker/nginx/conf目录下的nginx.conf配置文件 worker_processes 1; events { worker_connections 1024; } http{ include mime.type; default_type application/octet-stream; sendfile on; keepalive_timeout 65; # 配置虚拟主机 192.168.32.255 server{ # 监听的IP和端口,配置192.168.32.255:80 listen 80; # 虚拟主机名称,这里配置IP地址 server_name 192.168.32.255; # 所有的请求都是以 / 开始,所有的请求都可以匹配此location location / { # 使用 root 指令指定虚拟主机目录即网页存放目录 # 例如:访问 http://ip/index.html 将找到 /usr/local/docker/nginx/wwwroot/html80/index.html # 例如:访问 http://ip/item/index.html 将找到 /usr/local/docker/nginx/wwwroot/html80/item/index.html root /usr/share/nginx/wwwroot/html80; # 指定欢迎页面,按从左到右顺序查找 index index.html index.htm; } } # 配置虚拟主机 192.168.32.255 server{ listen 8080; server_name 192.168.32.255; location / { root /usr/share/nginx/wwwroot/html8080; index index.html index.htm; } } } Nginx 反向代理 代理服务器 客户端在发送请求时,不会直接发送给目的主机.而是先发给代理服务器,代理服务器接收客户端请求后,再向主机发出,并接收目的主机返回的数据,存放在代理服务器的硬盘中,再发送给客户机 代理服务器作用 提高访问速度: 由于目标主机返回的数据存放在代理服务器的硬盘中,因此下一次客户在访问相同的站点数据时,会直接从代理服务器的硬盘中读取,起到了缓存的作用,尤其对于热门站点能明显提高请求速度 防火墙作用: 由于所有客户机请求都必须通过代理服务器访问远程站点,因此可在代理服务器上设限,过滤掉某些不安全信息 通过代理服务器访问不能访问的目标站点: 互联网上有许多开放的代理服务器,客户机在访问受限时,可通过不受限的代理服务器访问目标站点 正向代理 架设在客户机和目标主机之间,只用于代理内部网络对Internet的连接请求,客户机必须指定代理服务器,并将本来要直接发送到web服务器上的http请求发送到代理服务器中 反向代理 反向代理服务器架设在服务器端,通过缓冲经常被请求的页面来缓解服务器的工作量,将客户机请求转发给内部网络上的目标服务器,并将从服务器上得到的结果返回给Internet上请求连接的客户端,此时代理服务器与目标主机一起对外表现为一个服务器 反向代理应用 防止外网对内网服务器的恶性攻击 缓存以减少服务器压力 访问安全控制 进行负载均衡,将用户请求分配给多个服务器 Nginx反向代理Tomcat 启动Tomcat容器: 启动两个Tomcat容器,映射端口为9090和9091,配置docker-compose.yml version: '3' services: tomcat1: image: tomcat container_name: tomcat1 ports: - 9090:8080 tomcat2: image: tomcat container_name: tomcat2 ports: - 9091:8080 配置Nginx反向代理: 修改 /usr/local/docker/nginx/conf 目录下的nginx.conf配置文件 user nginx; worker_processes 1; events { worker_connection 1024; } http { include mime.type; default_type application/octet-stream; sendfile on; keepalive_timeout 65; # 配置一个tomcat1代理服务器 upstream tomcat_server1 { server 192.168.32.255:9090; } # 配置一个tomcat2代理服务器 upstream tomcat_server2{ server 192.168.32.255:9091; } server { listen 80; server_name admin.service.itoken.oxford.com # 所有的请求都是以 / 开始,所有的请求都可以匹配此location location / { # 域名 admin.service.itoken.oxford.com的请求全部转发到tomcat_server1,即tomcat1服务器上 proxy_pass http://tomcat_server1; # 欢迎页面,按照从左到右的顺序查找页面 index index.jsp index.html index.htm; } } server{ listen 80; server_name admin.web.itoken.oxford.com location / { # 域名 admin.web.itoken.oxford.com的请求全部转发到tomcat_server2,即tomcat2服务器上 proxy_pass http://tomcat_server2; index index.jsp index.html index.htm; } } } Nginx负载均衡 负载均衡 负载均衡建立在现有网络结构之上,提供了一种廉价有效透明的方法扩展网络设备和服务器的带宽,增加吞吐量,加强网络数据处理能力,提高网络的灵活性和可用性 负载均衡(Load Balance),分摊到多个操作单元上进行执行,例如Web服务器,FTP服务器,企业关键应用服务器和其它关键任务服务器等,从而共同完成工作任务 Nginx 实现负载均衡 需求: nginx作为负载均衡服务器,用户请求先到达nginx,再由nginx根据负载均衡配置将请求转发到tomcat服务器 nginx负载均衡服务器:192.168.32.255:80 tomcat服务器:192.168.32.255:9090 Nginx配置负载均衡: 修改 /usr/local/docker/nginx/conf下的nginx.conf配置文件 user nginx; worker_processes 1; events { worker_connection 1024; } http { include mime.type; default_type application/octet-stream; sendfile on; keepalive_timeout 65; upstream myapp { server 192.168.32.255:9090 weight=10; server 192.168.32.255:9091 weight=10; } server{ listen 80; server_name nginx.oxford.com; location / { proxy_pass http://myapp; index index.jsp index.html index.htm; } } } Nginx 解决跨域问题 跨域问题 在浏览器端进行Ajax请求时会出现跨域问题 跨域: 浏览器不能执行其它网站的脚本.是由于浏览器的同源策略造成的,是浏览器对JavaScript施加的安全限制 同源 同源: 域名,协议,端口均相同 解决跨域问题方式 使用CORS(跨资源共享)解决跨域问题 CORS是W3C标准,全称"跨资源共享"(Cross-origin resource sharing),允许浏览器向跨源服务器发出XMLHttpRequest请求,从而克服了Ajax只能同源使用的限制 CORS需要浏览器和服务器同时支持 目前,所有浏览器都支持该功能,IE浏览器不能低于IE10. 整个CORS通信过程,都是通过浏览器自动完成,不需要用户参与.对于开发者来说,CORS通信与同源Ajax通信没有差别,代码完全一样. 浏览器一旦发现Ajax请求跨源,就会自动添加一些附加的头信息,有时还会多出一次附加 的请求,但用户不会有感觉 实现CORS通信的关键是服务器,只要服务器实现了CORS接口,就可以跨域通信 在header中设置:Access-Control-Allow-Origin(在服务器请求控制器中的controller类标注 @CrossOrigin(value="*") 注解) 使用JSONP解决跨域问题 JSONP:(JSON with Padding),JSON的一种"使用模式:,可用于解决主流浏览器的跨域数据访问问题 由于同源策略,一般server1.example.com的网页无法与server2.example.com的服务器进行访问,而HTML的< script>元素是个例外 利用< script>元素这个开放策略,网页可以得到从其它来源动态产生的JSON资料,而使用的这种模式就叫JSONP 用JSONP抓到的资料不是JSON,而是任意的JavaScript,用JavaScript直译器执行而不是用JSON解析器解析 需要目标服务器配合一个callback函数 CORS与JSONP比较: CORS与JSON使用的目的相同,但是比JSONP更强大 CORS支持所有类型的HTTP请求 JSONP只支持GET请求, JSON的优势在于支持老式浏览器,以及可以向不支持CORS的网站请求数据 Nginx反向代理解决跨域问题 当服务器无法设置header或提供callback函数时就可以采用Nginx反向代理解决跨域问题 Nginx配置跨域 在 /usr/local/docker/nginx/conf中的nginx.conf里的location中增加配置(Get:字体跨域): add_header Access-Control-Allow-Origin *或域名; add_header Access-Control-Allow-Headers X-Requested-with; add_header Access-Control-Allow-Methods GET,POST,OPTIONS; 配置 /usr/local/docker/nginx/conf中的nginx.conf配置文件(POST:上传文件): user nginx; worker_processes 1; events { worker_connection 1024; } http { include mime.types; default_type application/octet-stream; sendfile on; keepalive_timeout 65; server { listen 80; server_name upload.myshop.com; add_header 'Access-Control-Allow-Origin' '*'; add_header 'Access-Control-Allow-Headers' 'DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-with,If-Modified-Since,Cache-Control,Content-Type,Content-Range,Range'; location / { proxy_pass http://192.168.32.255:8888; if($request_method = 'OPTIONS'){ add_header Access-Control-Allow-Origin *; add_header Access-Control-Allow-Headers X-Requested-with; add_header Access-Control-Allow-Methods GET,POST,PUT,DELETE,PATCH,OPTIONS; # 解决假请求问题,如果是简单请求则没有这个问题,这里是上传文件,首次请求为OPTIONS方式,实际请求为POST方式 add_header Access-Control-Allow-Headers' 'DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-with,If-Modified-Since,Cache-Control,Content-Type,Content-Range,Range; return 200; } } } }

优秀的个人博客,低调大师

Linux基础-20day-linux磁盘分区(fdisk/parted)

Linux磁盘分区(fdisk/parted) 一. 分区类型及表示方式 磁盘分区划分:常见的硬盘可以划分为主分区、扩展分区、和逻辑分区(MBR分区方式)。通常情况下主分区只有4个,而扩展分区看成一个特殊的主分区类型,在扩展分区可以建立逻辑分区。主分区一般用来安装操作系统,扩展分区则多用来储存文件数据。 MBR分区方案使用硬盘的第一个物理扇区中的64个字节作为分区表的空间保存硬盘分区信息,每个分区的信息要占16个字节。所以,MBR分区表最多只能保存4个分区的分区信息。 16个字节的分区信息保存有分区活动状态标志、文件系统标识、起止柱面号、磁头号、扇区号、起始扇区位置(4个字节)、分区总扇区数目(4个字节)等内容。这里最重要的是:分区的起始扇区位置与分区的总扇区数,都是用4个字节表示的。 一般每个扇区的容量是512字节,4个字节的扇区能表示的最大容量是2TB,由4可知,在MBR分区表中,分区的起始位置不能大于2TB,分区的最大容量,也不能大于2TB。所以,对2TB以上容量的物理硬盘,不适合使用MBR分区方案。 磁盘分区表示:Linux系统根据设备类型对硬盘设备进行识别,如果是IDE硬盘,计算机中被识别为“hd”,第一块设备被识别为“hda”,第二块设备被识别为“hdb”,以此类推。如果是ATA、SCSI等设备,将被识别为“sd”,同样依次类推,分别为“sda、sdb、sde”等。 第一块盘的第一个主分区应该是“sda1”,第一块磁盘的第二个主分区应该是“sda2”,第二块盘的第一个主分区应该是“sdb1”,第二块硬盘的第二个主分区应该是“sdb2”依此类推。 主分区共有4个,而扩展分区看成一个特殊的主分区,逻辑分区是建立在扩展分区之上。所以,第一个逻辑分区的表示方法是“sda5”,后面分依此类推。 二.磁盘分区 2.1传统MBR分区方式(fdisk) (1)fdisk -l 查看磁盘分区表 ########################################################### [root@localhost ~]# fdisk -l 磁盘 /dev/sdb:10.7 GB, 10737418240 字节,20971520 个扇区 Units = 扇区 of 1 * 512 = 512 bytes 扇区大小(逻辑/物理):512 字节 / 512 字节 I/O 大小(最小/最佳):512 字节 / 512 字节 磁盘 /dev/sda:21.5 GB, 21474836480 字节,41943040 个扇区 Units = 扇区 of 1 * 512 = 512 bytes 扇区大小(逻辑/物理):512 字节 / 512 字节 I/O 大小(最小/最佳):512 字节 / 512 字节 磁盘标签类型:dos 磁盘标识符:0x0001038f 设备 Boot Start End Blocks Id System /dev/sda1 * 2048 2099199 1048576 83 Linux /dev/sda2 2099200 41943039 19921920 8e Linux LVM 磁盘 /dev/mapper/cl-root:18.2 GB, 18249416704 字节,35643392 个扇区 Units = 扇区 of 1 * 512 = 512 bytes 扇区大小(逻辑/物理):512 字节 / 512 字节 I/O 大小(最小/最佳):512 字节 / 512 字节 磁盘 /dev/mapper/cl-swap:2147 MB, 2147483648 字节,4194304 个扇区 Units = 扇区 of 1 * 512 = 512 bytes 扇区大小(逻辑/物理):512 字节 / 512 字节 I/O 大小(最小/最佳):512 字节 / 512 字节 ########################################################### (2)fdisk 磁盘名称 #对硬盘进行分区 (3)分区实例:fdisk /dev/sdb ########################################################### [root@localhost ~]# fdisk /dev/sdb 欢迎使用 fdisk (util-linux 2.23.2)。 更改将停留在内存中,直到您决定将更改写入磁盘。 使用写入命令前请三思。 Device does not contain a recognized partition table 使用磁盘标识符 0x951146d9 创建新的 DOS 磁盘标签。 命令(输入 m 获取帮助):m #在此输入指令m,获取帮助 命令操作 a toggle a bootable flag #设置分区启动标识(*) b edit bsd disklabel #编辑bsd磁盘标签 c toggle the dos compatibility flag #设置dos兼容模式 d delete a partition #删除一个分区 g create a new empty GPT partition table #创建新的空GPT分区 G create an IRIX (SGI) partition table#创建新的SGI分区表 l list known partition types #显示分区类型 m print this menu #显示帮助菜单 n add a new partition #创建新分区 o create a new empty DOS partition table #创建新分区表 p print the partition table #显示分区列表信息 q quit without saving changes #不保存退出 s create a new empty Sun disklabel#创建新的sun磁盘标签 t change a partition's system id #修改分区id,l查看id u change display/entry units #修改容量单位 v verify the partition table #验证分区表 w write table to disk and exit #保存并推出 x extra functionality (experts only) #扩展功能 命令(输入 m 获取帮助):n #创建新分区 Partition type: p primary (0 primary, 0 extended, 4 free) #创建主分区 e extended #创建扩展分区 Select (default p): p #创建主分区 分区号 (1-4,默认 1):1 #选择主分区编号1 起始 扇区 (2048-20971519,默认为 2048): #回车,使用默认2048开始分区 Last 扇区, +扇区 or +size{K,M,G} (2048-20971519,默认为 20971519):+2G #指定创建分区大小为2G 分区 1 已设置为 Linux 类型,大小设为 2 GiB 命令(输入 m 获取帮助):p #显示分区信息(是否创建成功) 磁盘 /dev/sdb:10.7 GB, 10737418240 字节,20971520 个扇区 Units = 扇区 of 1 * 512 = 512 bytes 扇区大小(逻辑/物理):512 字节 / 512 字节 I/O 大小(最小/最佳):512 字节 / 512 字节 磁盘标签类型:dos 磁盘标识符:0xb46e950b 设备 Boot Start End Blocks Id System /dev/sdb1 2048 4196351 2097152 83 Linux 令(输入 m 获取帮助):n #创建新分区 Partition type: p primary (1 primary, 0 extended, 3 free) e extended Select (default p): e #创建扩展分区 分区号 (2-4,默认 2):2 #选择分区号为2 起始 扇区 (4196352-20971519,默认为 4196352): #回车 将使用默认值 4196352 Last 扇区, +扇区 or +size{K,M,G} (4196352-20971519,默认为 20971519): #回车将剩余空间全部划分为扩展分区 将使用默认值 20971519 分区 2 已设置为 Extended 类型,大小设为 8 GiB 命令(输入 m 获取帮助):n #创建新分区 Partition type: p primary (1 primary, 1 extended, 2 free) l logical (numbered from 5) #创建逻辑分区 Select (default p): l #创建逻辑分区 添加逻辑分区 5 起始 扇区 (4198400-20971519,默认为 4198400): #回车 将使用默认值 4198400 Last 扇区, +扇区 or +size{K,M,G} (4198400-20971519,默认为 20971519):+2G #创建逻辑分区大小为2G 分区 5 已设置为 Linux 类型,大小设为 2 GiB 命令(输入 m 获取帮助):p #显示分区列表,确认是否创建 磁盘 /dev/sdb:10.7 GB, 10737418240 字节,20971520 个扇区 Units = 扇区 of 1 * 512 = 512 bytes 扇区大小(逻辑/物理):512 字节 / 512 字节 I/O 大小(最小/最佳):512 字节 / 512 字节 磁盘标签类型:dos 磁盘标识符:0x5f024b01 设备 Boot Start End Blocks Id System /dev/sdb1 2048 4196351 2097152 83 Linux /dev/sdb2 4196352 20971519 8387584 5 Extended /dev/sdb5 4198400 8392703 2097152 83 Linux 命令(输入 m 获取帮助):d #删除分区 分区号 (1,2,5,默认 5):5 #选择删除的分区编号5 分区 5 已删除 命令(输入 m 获取帮助):p #显示分区列表,确认是否删除 磁盘 /dev/sdb:10.7 GB, 10737418240 字节,20971520 个扇区 Units = 扇区 of 1 * 512 = 512 bytes 扇区大小(逻辑/物理):512 字节 / 512 字节 I/O 大小(最小/最佳):512 字节 / 512 字节 磁盘标签类型:dos 磁盘标识符:0x5f024b01 设备 Boot Start End Blocks Id System /dev/sdb1 2048 4196351 2097152 83 Linux /dev/sdb2 4196352 20971519 8387584 5 Extended 命令(输入 m 获取帮助):w #保存并退出 The partition table has been altered! Calling ioctl() to re-read partition table. 正在同步磁盘。 ########################################################### 如果想要系统读取到新分区列表信息,有两种方式:对系统进行重启;或使用partprobe命令让内核立即读取分区列表。 [root@localhost ~]# partprobe /dev/sdb 2.2GPT分区方式(parted) 对与上述传统MBR分区方式而言,最多4个主分区,无法创建大于2TB分区。现在有一种新的GPT分区方式,不受以上限制,此外,GPT分区方式,提供了分区表冗余用于实现分区表的备份与安全。 改变分区方式后,原有磁盘中的数据将全部丢失,因此需要做好数据备份。 命令格式:parted [选项] [磁盘(命令)(参数)] parted主要选项:-l 显示所有分区列表 主要操作命令: 命令 功能 cp 将文件系统复制到另一个分区 mklabel 分区表格式 (mklabel 分区表格式) 指定分区表格式 mkpart mkpart 分区类型 [文件系统类型] 开始 结束,创建一个分区 rm NUMBER 删除指定分区 print 打印分区表信息 name NUMBER NAME 修改指定分区号对应的名称 rescue START END 挽救临近“起始点”、“终止点”的遗失的分区 set NUMBER FLAG STATE 修改指定分区号的分区标识 select DEVICE 选择要编辑的设备 help 显示帮助命令 quit 退出 案例选用第三块磁盘: (1)修改磁盘分区表类型 [root@localhost ~]# parted /dev/sdc mklabel gpt #修改分区表为GPT格式 警告: The existing disk label on /dev/sdc will be destroyed and all data on this disk will be lost. Do you want to continue? #磁盘数据将丢失,是否继续 是/Yes/否/No? yes #继续 修改完成后,通过print指令查看修改结果。 [root@localhost ~]# parted /dev/sdc print Model: VMware, VMware Virtual S (scsi) Disk /dev/sdc: 10.7GB Sector size (logical/physical): 512B/512B Partition Table: gpt #分区表类型为GPT Disk Flags: Number Start End Size File system Name 标志 (2)创建及删除分区 创建新分区需要使用parted命令的mkpart指令,格式如下: parted [磁盘] mkpart 分区类型 文件系统类型 开始 结束 其中,mkpart指令为创建新的分区,分区类型有primary(主分区)、logical(逻辑分区)、extended(扩展分区),文件类型有:fat16、fat32、ext2、ext3、ext4、Linux-swap等,开始于结束标记分区的开始和结束位置(默认单位MB)。 创建分区:创建主分区大小(1Mb-2G),格式ext4 [root@localhost ~]# parted /dev/sdc mkpart primary ext4 1 2G 查看是否创建成功: [root@localhost ~]# parted /dev/sdc print Model: VMware, VMware Virtual S (scsi) Disk /dev/sdc: 10.7GB Sector size (logical/physical): 512B/512B Partition Table: gpt Disk Flags: Number Start End Size File system Name 标志 1 1049kB 2000MB 1999MB primary 删除已创建的分区 [root@localhost ~]# parted /dev/sdc rm 1 #rm接分区号,删除 查 看是否创建已删除: [root@localhost ~]# parted /dev/sdc print Model: VMware, VMware Virtual S (scsi) Disk /dev/sdc: 10.7GB Sector size (logical/physical): 512B/512B Partition Table: gpt Disk Flags: Number Start End Size File system Name 标志 [root@localhost ~]# 三、磁盘格式化及挂载 对磁盘进行分区后,需要对磁盘进行分区及挂载。 3.1格式化 Linux系统使用mkfs命令对磁盘进行格式化。 使用权限 : 超级使用者 格式: mkfs [-V] [-t fstype] [fs-options] filesys [blocks] [-L Lable] 主要参数: 参数 功能 -V 详细显示模式 -t 指定文件系统类型 Eg: (1)对/dev/sdb1分区进行格式化,指定文件系统格式ext4 [root@localhost ~]# mkfs -t ext4 /dev/sdb1 (2)对交换分区使用mkswap进行格式化 #将/dev/sdb2格式化为交换分区 [root@localhost ~]# mkswap /dev/sdb2 3.2挂载分区 将磁盘分区、格式化后需要将分区进行挂载,然后进行使用。两种方式:(1)mount命令直接挂载,系统重启后失效;(2)修改/etc/fstab文件,系统重启后任然有效。 Eg: (1)将分区/dev/sdb1挂载到/mnt/sdb1目录 [root@localhost ~]# mkdir /mnt/sdb1 [root@localhost ~]# mount /dev/sdb1 /mnt/sdb1 [root@localhost ~]# df -h 文件系统 容量 已用 可用 已用% 挂载点 /dev/mapper/cl-root 17G 1.1G 16G 7% / devtmpfs 478M 0 478M 0% /dev tmpfs 489M 0 489M 0% /dev/shm tmpfs 489M 6.7M 482M 2% /run tmpfs 489M 0 489M 0% /sys/fs/cgroup /dev/sda1 1014M 139M 876M 14% /boot tmpfs 98M 0 98M 0% /run/user/0 /dev/sdb1 2.0G 6.0M 1.8G 1% /mnt/sdb1 [root@localhost ~]# 个人公众号:

优秀的个人博客,低调大师

Day2 鸿蒙,从“打工人”看代码创建布局

上文档: HarmonyOS提供了Ability和AbilitySlice两个基础类。有界面的Ability绑定了系统的Window进行UI展示,且具有生命周期。AbilitySlice主要用于承载Ability的具体逻辑实现和界面UI,是应用显示、运行和跳转的最小单元。AbilitySlice通过setUIContent()为界面设置布局。 组件需要进行组合,并添加到界面的布局中。在Java UI框架中,提供了两种编写布局的方式: 在代码中创建布局:用代码创建Component和ComponentContainer对象,为这些对象设置合适的布局参数和属性值,并将Component添加到ComponentContainer中,从而创建出完整界面。 在XML中声明UI布局:按层级结构来描述Component和ComponentContainer的关系,给组件节点设定合适的布局参数和属性值,代码中可直接加载生成此布局。 这一次为大家带来的就是“在代码中创建布局”。 涵盖核心知识点包括:(实战Demo源码地址:https://github.com/CoderMrYe/HarmonyStudy) 1、创建步骤: (1)声明布局 DirectionalLayout directionalLayout = new DirectionalLayout(getContext()); (2)设置布局大小 directionalLayout.setWidth(ComponentContainer.LayoutConfig.MATCH_PARENT); directionalLayout.setHeight(ComponentContainer.LayoutConfig.MATCH_PARENT); (3)设置布局属性及ID(ID视需要设置即可) directionalLayout.setOrientation(Component.VERTICAL); directionalLayout.setPadding(32, 32, 32, 32); (4)组件创建 Text text = new Text(getContext()); //组件初始化 text.setText("???");//组件属性设置 text.setTextSize(50); text.setId(100); (5)为组件添加对应布局的布局属性 DirectionalLayout.LayoutConfig layoutConfig = new DirectionalLayout.LayoutConfig(DirectionalLayout.LayoutConfig.MATCH_CONTENT, DirectionalLayout.LayoutConfig.MATCH_CONTENT); layoutConfig.alignment = LayoutAlignment.HORIZONTAL_CENTER; text.setLayoutConfig(layoutConfig); (6)将组件添加到布局中(多个组件,重复步骤456) directionalLayout.addComponent(text); (7)将布局作为根布局添加到视图树中 super.setUIContent(directionalLayout); 本文由博客一文多发平台 OpenWrite 发布!

优秀的个人博客,低调大师

Java编程基础阶段笔记 day 07 面向对象编程(上)

​ 面向对象编程 笔记Notes 面向对象三条学习主线 面向过程 VS 面向对象 类和对象 创建对象例子 面向对象的内存分析 类的属性:成员变量 成员变量 VS 局部变量 类的方法 方法的重载 可变个数形参 面向对象:封装性 访问权限修饰符 构造方法(构造器) 给属性赋值的方法 UML类图 this 关键字 面向对象学习主线 类及类的成员:属性,方法,构造器,代码块,内部类 面向对象的三大特性:封装性,继承性,多态性 其他关键字:this,super,interface,final,static...... 面向过程 vs 面向对象 面向过程:强调的是功能行为 面向对象 :强调具备了功能的对象 类和对象的区别 类:抽象的(汽车设计模板) 对象:具体的,类的实例(根据模板造出的汽车) 类的成员:属性和方法 属性 = field = 成员变量 (成员)方法 = 函数 = method 面向对象的例子 1.创建一个类,并在类中提供必要的属性和方法 2.由类派生出对象。(创建对象) 3.调用对象中的属性和方法。(对象名.属性名/方法名) //创建一个类 class Person{ //属性 String name; int age; char sex; //方法 public void run(){ System.out.println(name + "跑起来"); } public void say(){ System.out.println(name + "今年" + age); } } // main 方法中 Person person = new Person(); //调用属性 :对象名.属性名 person.name = "王庆港"; //给属性赋值 person.age = 23; //获取属性的值 String name = person.name; System.out.println("name=" + name); //调用方法 :对象名.方法名 person.run(); person.say(); 面向对象的内存分析 同一个类创建的多个对象,每个对象独自拥有一份属性。 当修改其中一个对象的属性的值后,其它对象的该属性不会受到影响 类的成员之 :属性(成员变量) 变量的分类: ①按照数据类型分 :基本数据类型 vs 引用数据类型 ②按照位置分 :成员变量 vs 局部变量 成员变量和局部变量 相同点: ①变量的声明的格式都是一样的。 ②变量都有作用域 ③变量都是先声明后使用 成员变量和局部变量 不同点: ①局部变量:在方法里,方法的形参,构造器中,构造器的形参,代码块 ②成员变量: 在类中方法等结构外 权限修饰符: ①局部变量:不能使用权限修饰符修饰 ②成员变量:可以使用四种权限修饰符(public protected 缺省的(default) private) 内存: ①局部变量:在内存的栈中 ②成员变量:在内存的堆(对象)中 默认值: ①局部变量 :没有默认值 ②成员变量 :有默认值(和数组元素的默认值是一样的) byte,short,int,long -> 0 float,double -> 0.0 boolean -> false char -> u0000 引用数据类型 -> null class Animal{ //属性(成员变量) public String name = "动物"; int legs; protected boolean isLive = true; {//代码块 String address = "";//局部变量 } public Animal(){} //构造器 public Animal(int sex){//构造器的形参 int a = 10;//局部变量 } //方法 public void say(int sex){//方法的形参 //局部变量 int age = 10; age = 20; name = "大锤"; } } 不定义对象的句柄,而直接调用这个对象的方法。这样的对象叫做匿名对象。 如:new Person().shout(); 类的成员:方法(method) Java里的方法不能独立存在,所有的方法必须定义在类里。 方法的声明格式: 修饰符 返回值类型 方法名(参数类型 形参1, 参数类型 形参2, ….){ 方法体程序代码 return 返回值; } 权限修饰符 :public protected 缺省的 private (先用public) ①void/具体的类型(基本数据类型、引用数据类型): ②void : 表示该方法没有返回值 具体的类型 :调用该方法会有返回值。 注意:返回数据需要使用return关键字。return 后面跟需要返回的数据。 方法名 :只需要遵守标识符的规则和规范即可 (形参相同的情况下,同一个类中的方法名不能相同)。 形参列表 :可以有0个1个或多个。多个之间使用","隔开。 ①作用 :用来通知方法的调用者调用此方法时需要传递数据。 ②注意:实参的类型必须和形参的类型保持一致 方法体 :方法功能的具体体现。 注意 :只有调用方法时方法体才会执行。 对象数组题目: 定义类Student,包含三个属性:学号number(int),年级state(int),成绩score(int)。创建20个学生对象,学号为1到20,年级和成绩都由随机数确定。 问题一:打印出3年级(state值为3)的学生信息。 问题二:使用冒泡排序按学生成绩排序,并遍历所有学生信息 提示: 1) 生成随机数:Math.random(),返回值类型double; 2) 四舍五入取整:Math.round(double d),返回值类型long。 class Student1{ int number; int state; int score; @Override public String toString() { return "Student1 [number=" + number + ", state=" + state + ", score=" + score + "]"; } } public class StuInfo { public static void main(String[] args) { // 创建对象数组 Student1[] studentArr = new Student1[20]; // 循环创建对象并赋值,传给对象 for (int i = 0; i < 20; i++) { Student1 student1 = new Student1(); student1.number = i; student1.state = (int)Math.round( (Math.random()*7)); student1.score = (int) (Math.random()*100); studentArr[i] = student1; } System.out.println("---------打印排序前的学生信息-------------"); for (int i = 0; i < studentArr.length; i++) { System.out.println(studentArr[i]); } System.out.println("----------打印state为3的学生信息---------"); // 循环查找对象数组中state值为3的对象,打印输出对象信息 for (int i = 0; i < studentArr.length; i++) { if (studentArr[i].state == 3) { System.out.println(studentArr[i]); } } System.out.println("----------------------------------------"); // 使用冒泡排序按学生成绩排序,并遍历所有学生信息 // 思路:两个循环遍历数组中的对象的成绩,若对象的成绩小于后一个,则交换对象的位置 for (int i = 0; i < studentArr.length -1; i++) { // 外层循环决定冒泡排序的次数,为数组长度-1 for (int j = 0; j < studentArr.length - i -1; j++) { // 内层循环决定每次多少次冒泡,为 if (studentArr[j].score > studentArr[j+1].score) { // 如果前面的对象小于大于后面的,就叫交换类数组地址 Student1 temp = studentArr[j]; studentArr[j] = studentArr[j+1]; studentArr[j+1] = temp; } } } // 注意!!!!!!!!!! // 冒泡排序交换的值的数组的下标为内循环的循环变量 System.out.println("------打印排序后的信息-------"); // 打印排序后的信息 for (int i = 0; i < studentArr.length; i++) { System.out.println(studentArr[i]); } } } 重载的概念、特点、实例 ①在同一个类中,允许存在一个以上的同名方法,只要它们的参数个数或者参数类型不同即可。 ②与返回值类型无关,只看参数列表,且参数列表必须不同。 (参数个数或参数类型)。调用时,根据方法参数列表的不同来区别。 ③示例: //返回两个整数的和 int add(int x,int y){return x+y;} //返回三个整数的和 int add(int x,int y,int z){return x+y+z;} //返回两个小数的和 double add(double x,double y){return x+y;} 注意!!: ①不同的形参列表 :形参的个数,顺序,类型不同 ②方法的重载和权限修饰符,返回值类型,形参的名字无关。 ③判断方法:只看 方法名 + 形参列表(看形参和实参的类型) 可变个数形参 格式 :变量的类型 ... 变量名 说明: ①可变形参的底层就是一个数组 ②在可变形参的方法中,和可变形参相同类型的数组的方法不构成重载。 ③在形参列表中可变形参只能放在最后 ④在同一个方法的形参列表中只能有一个可变形参。 ⑤ 可变形参的个数可以是0个1个或多个 方法的参数传递 基本数据类型的参数传递 引用数据类型的参数传递 方法的参数传递 面向对象:封装 为什么要使用封装性? 在创建对象以后,就可以通过对象名.属性名这种方式对属性直接进行操作。这种操作对于属性只有类型和范围的限制。但是在实际开发中我们会有更多的其它的限制条件。而这些限制条件又不能在属性的声明处加以限制。我们采取取如下方式 ①使用权限修饰符对属性进行权限的限制,那么在类的外部就不能随意的再调用类中的属性 ②提供公共的方法,在方法中可以加以限制其它的条件。然后可以通过该方法给属性赋值和获取属性的值。 封装性的体现(狭义上): ①将属性私有化。(private修饰属性) ②提供公共的set/get方法。(set方法用来给属性赋值,get方法用来获取属性的值) 封装性的体现(广义上): ①可以使用四种权限修饰符:private,缺省的,protected,public ②四种权限修饰符可以修饰 :属性,方法,构造器,内部类 ③类只能被public和缺省的修饰。 四种访问权限修饰符 构造方法(构造器) 构造器的特征 它具有与类相同的名称 它不声明返回值类型。(与声明为void不同) 不能被static、final、synchronized、abstract、native修饰,不能有return语句返回值 构造器的作用:创建对象;给对象进行初始化 如:Order o = new Order(); Person p = new Person(“Peter”,15); 根据参数不同,构造器可以分为如下两类: 隐式无参构造器(系统默认提供) 显式定义一个或多个构造器(无参、有参) 注 意: Java语言中,每个类都至少有一个构造器 默认构造器的修饰符与所属类的修饰符一致 一旦显式定义了构造器,则系统不再提供默认构造器 一个类可以创建多个重载的构造器 父类的构造器不可被子类继承 构造器重载使得对象的创建更加灵活,方便创建各种不同的对象。 给属性赋值的方法 赋值的位置: ① 默认初始化:int a; ② 显式初始化:int a = 0; ③ 构造器中初始化 ④ 通过“对象.属性“或“对象.方法”的方式赋值 赋值的先后顺序: ① - ② - ③ - ④ JavaBean:Java语言编写的可重用组件 定义:是一个普通的Java类,但是符合如下标准 ①类是公共的 ②有一个无参的公共的构造器 ③有属性,且有对应的get、set方法 UML类图 ①+ 表示 public 类型, - 表示 private 类型,#表示protected类型 ②方法的写法:方法的类型(+、-) 方法名(参数名:参数类型):返回值类型 this 关键字 this 是什么? ①它在方法内部使用,即这个方法所属对象的引用; ②它在构造器内部使用,表示该构造器正在初始化的对象。 this作用域:this 可以调用类的属性、方法和构造器 适用情形:当在方法内需要用到调用该方法的对象时,就用this。 具体的:我们可以用this来区分属性和局部变量。 public void setAge(int age){ age = age;//局部变量 :就近原则(属性名和局部变量名相同时默认调用的是局部变量) System.out.println("===========" + age); } this 调用构造器 总结Summary 面向对象的内存分析 成员变量与局部变量 构造器 函数重载

优秀的个人博客,低调大师

Java编程基础阶段笔记 day01 Java语言概述

​目录内容 DOS命令电脑配置Java语言的特性Java两种核心机制Java语言环境搭建第一个Java程序注释Java语句说明编程风格作业常用的DOS命令 dir : 列出当前目录下的文件以及文件夹 md : 创建目录 rd : 删除目录 cd : 进入指定目录 cd.. : 退回到上一级目录 cd: 退回到根目录 del : 删除文件 exit : 退出 dos 命令行 补充:echo javase>1.doc 常用快捷键 ← →:移动光标 ↑ ↓:调阅历史操作命令 Delete和Backspace:删除字符 电脑配置推荐 Dell 游匣 机械革命 拯救者 机械师 HP暗影精灵 宏基 暗影骑士 雷神 微星 cpu i7(6代) i5(7代) -- 全部是标压 内存 16G Java语言的特性 面向对象:类、对象;封装、继承、多态 健壮性:去掉指针、内存申请释放 跨平台:JVM Java两种核心机制 Java虚拟机(Java Virtual Machine) 垃圾收集机制(Garbage Collection) Java环境搭建 JRE、JVM、JDK区别 JDK(Java Development Kit Java开发工具包) JDK包含JRE JRE(Java Runtime Environment Java运行环境) JDK下载安装 path: window操作系统执行命令时,所要搜寻的路径 D:developer_toolsJavajdk1.8.0_131bin; %JAVA_HOME%bin; JAVA_HOME= D:developer_toolsJavajdk1.8.0_131 希望D:developer_toolsJavajdk1.8.0_131路径下的命令可以在任何文件路径下执行 第一个Java程序 创建Java源文件->编译javac->运行java class文件 class Test{ public static void main(String[] args){ System.out.println("你好"); } } 一个源文件中有几个类就编译出几个字节码文件 System、String、类名首字母大写 Javac 编译 Java 运行 println 与print 区别 注释: 单行注释、多行注释文档注释 多行注释不能嵌套使用 文档注释(Java特有) 格式: /** @author 指定Java程序的作者 @version 指定源文件的版本 */ Java语句说明 同一个源文件中的多个类,只能有一个类被public修饰 public所修饰的类名必须与源文件一致 Java严格区分大小写 一个程序必须有程序的入口 每行语句以分号结尾 编程风格 注释类或方法 tab缩进、运算符两边空格 5 + 3 行尾风格 class demo{ 换行符n 制表符t 作业 独立编写HelloJava程序,并配上必要的注释。 将个人的基本信息(姓名、性别、籍贯、住址)打印到控制台上输出。各条信息分别占一行。 结合n(换行),t(制表符),空格等在控制台打印出如下图所示的效果。 总结SummaryJDK,JRE,JVM的关系。 环境变量path配置及其作用。 Java程序的编写、编译、运行步骤: Java程序编写的规则。 在配置环境、编译、运行各个步骤中常见的错误以及解决方法。

优秀的个人博客,低调大师

python 数据分析基础 day1-初窥内容

在读这本书之前,我已经有开始学python,用的是anaconda 的jupyter notebook。 看了《python 数据分析基础》的前言部分,发现这本书的实用性很高,其讲解的内容很贴近进行分析时的实际情况,如批量自动化批量处理数据、从不同的文件导入数据、数据库的更新。 从整体来说,这本书涉及到了数据提取及预处理、分析、可视化这三个板块。书的逻辑与开展分析的流程大致相同,这本书可视为python分析的基础书籍。

优秀的个人博客,低调大师

DockerCon SF 18 Day One 速记 - 从容器到云原生

主论坛精彩回味 又是一年DockerCon,容器社区相聚在美丽的旧金山。主会场开幕后,在金州勇士队Hype Man - Franco Finn 带动的热烈现场气氛中,迎来了Docker的主教练(CEO)Steve Singh。 过去一年Docker Community的持续增长,新增超过100万开发者和容器化应用。 Docker公司产品经理Scott Johnston,介绍了随着容器技术的普及,容器技术已经深入到计算的各个层面,从大型主机到云平台再到IoT设备,从传统应用到AI、区块链、函数计算。容器技术已经无处不在。 又到了Demo时刻,这次为Demo god献祭的是非常San Francisco风格的幸运签饼(fortune cookie)。 首先为开发者揭示了Docker Desktop的最新功能,基于应用模板的应用开发流程。 从应用模

优秀的个人博客,低调大师

【Java入门提高篇】Day17 Java异常处理(下)

今天继续讲解java中的异常处理机制,主要介绍Exception家族的主要成员,自定义异常,以及异常处理的正确姿势。 Exception家族 一图胜千言,先来看一张图。 Exception这是一个父类,它有两个儿子,IOException和RuntimeException,每个儿子都很能生,所以它有着一堆的孙子,但其实,Exception家族还有一个大家伙,那就是Throwable,这是一个接口,看名字就知道意思,就是“可被抛出”嘛,它还有一个同父异母的哥哥,那就是Error,这家伙可厉害了,Error类一般是指与虚拟机相关的问题,如系统崩溃,虚拟机错误,内存空间不足,方法调用栈溢出等。catch语句里,不仅可以catch住Exception,还能catch住Error(什么?你真的打算catchError??程独秀同学,你先坐下。)一般情况下,是不能捕获Error的,对于这类错误,Java编译器不去检查他们。对于这类错误的导致的应用程序中断,仅靠程序本身无法恢复和预防,遇到这样的错误,建议让程序终止。除非你有把握能正确处理,否则程独秀同学还是坐下吧(滑稽)。 UncheckedException和CheckedException 你也许会一脸懵逼,???,这是啥?异常也是分派别的,Unchecked Exception表示“未检查异常“,CheckedException自然就是”已检查异常“,派生于Error或者RuntimeException的异常称为unchecked异常,所有其他的异常成为checked异常。那问题来了,为啥要区分这两种异常? 我们可以再看看上面那个图,可以看出,RuntimeException和Error都是由程序内部引发的错误,比如上一篇里所说的空指针和算术异常。而CheckedException则大都是由外部因素导致的,如文件无法找到异常,这是虚拟机无法掌控的情况,当出现异常,虚拟机也只能一脸懵逼,不知道该如何是好,所以当有可能发生时,就必须要使用try..catch去捕获它,而对于Unchecked Exception时,大部分是由于代码引发的,所以只要代码写的足够完善,是不会抛出这样的异常的,所以也不强制要求捕获。 所以原因其实很简单,编译器将检查你是否为所有的已检查异常提供了异常处理机制,比如说我们使用Class.forName()来查找给定的字符串的class对象的时候,如果没有为这个方法提供异常处理,编译是无法通过的。已检查异常的意义就在于让你知道,这地方是有可能抛异常的,你要注意了,赶紧捕获了。 自定义异常 那么如何自定义一个异常呢?其实很简单,只需要继承Exception类就好了。看下面的栗子: public class MyException extends Exception { public MyException() { super(); } public MyException(String message) { super(message); } public MyException(String message, Throwable cause) { super(message, cause); } public MyException(Throwable cause) { super(cause); } protected MyException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { super(message, cause, enableSuppression, writableStackTrace); } } MyException继承了Exception类,重写了构造函数,并没有加自己的逻辑,只是调用了父类的方法。你看,自定义一个异常其实很简单吧。看到这你也许又疑惑了,这尼玛好像就是给Exception换了个名字,有啥用??? 别急,别急,你忘了吗,Exception不仅是可以捕获的,还是可以主动抛出的,所以当遇到某些特定的情况时,我们就可以主动抛出异常,然后在调用时去捕获它,获取异常信息,如果直接用Exception的话,那么捕获的时候,会把所有的异常,该捕获不该捕获的都一起捕获了,那么就没法区分哪些是我们主动抛出来的异常了,这样就无法对那些异常进行特殊处理了。 异常处理的正确姿势 接下来要简单介绍一个实际使用中常用的异常处理方法——异常链化处理。 在一些大型的,模块化的软件开发中,一旦一个地方发生异常,则如骨牌效应一样,将导致出现一连串的异常。假设B模块需要调用A模块的方法,如果A模块发生异常,则B也将不能完成而发生异常,但是B在抛出异常时,会将A的异常信息掩盖掉,这将使得异常的根源信息丢失。而使用异常的链化可以将多个模块的异常串联起来,使得异常信息不会丢失。 异常链化就是用一个异常对象为参数构造新的异常对象。新的异对象将包含先前异常的信息。这项技术主要是异常类的一个带Throwable参数的函数来实现的。这个当做参数的异常,我们叫他根源异常(cause)。如果你细心一点的话,会发现上面的栗子里也有一个叫做cause的东西,没错,说的其实就是它,在new一个新的异常时,将之前的异常信息传入构造函数即可。下面再用一个简单的栗子进行说明: public class Test { public static void main(String[] args) { System.out.println("请输入2个加数"); int result; try { result = add(); System.out.println("结果:"+result); } catch (Exception e){ e.printStackTrace(); } } /** * 执行加法计算 */ private static int add() throws Exception { int result; try { List<Integer> nums =getInputNumbers(); result = nums.get(0) + nums.get(1); }catch(InputMismatchException immExp){ //链化:以一个异常对象为参数构造新的异常对象。 throw new Exception("计算失败",immExp); } return result; } /** * 获取输入的整数 */ private static List<Integer> getInputNumbers() { List<Integer> nums = new ArrayList<>(); Scanner scan = new Scanner(System.in); try { int num1 = scan.nextInt(); int num2 = scan.nextInt(); nums.add(new Integer(num1)); nums.add(new Integer(num2)); }catch(InputMismatchException immExp){ throw immExp; }finally { scan.close(); } return nums; } } 输出如下: 请输入2个加数 d d java.lang.Exception: 计算失败 at com.frank.chapter17.Test.add(Test.java:35) at com.frank.chapter17.Test.main(Test.java:18) Caused by: java.util.InputMismatchException at java.util.Scanner.throwFor(Scanner.java:864) at java.util.Scanner.next(Scanner.java:1485) at java.util.Scanner.nextInt(Scanner.java:2117) at java.util.Scanner.nextInt(Scanner.java:2076) at com.frank.chapter17.Test.getInputNumbers(Test.java:47) at com.frank.chapter17.Test.add(Test.java:31) ... 1 more 可以看到,当输入的不是整数时,发生了异常,在getInputNumbers方法里没有处理这个异常,而是将它继续抛出,在add方法里捕获了异常之后,以该异常为构造参数,重新抛出了一个异常,从打印输出的信息可以看到,不仅仅有第二次抛出的异常信息,第一次的输出信息不匹配异常的详细信息也包含在了里面,衔接在Causedby之后,形成了一条异常链,这样可以方便我们更快的排查问题所在。 至此,异常就讲解完毕了,希望能给大家带来一些启发和思考,如果觉得还算ok的话,记得动动小手点推荐,让更多人可以看到,也欢迎关注我的博客,会持续更新的。如果有什么讲的不好的地方。。。emmmmmm,你倒是来打我呀(逃) 真正重要的东西,用眼睛是看不见的。

优秀的个人博客,低调大师

【Java入门提高篇】Day16 Java异常处理(上)

当当当当当当,各位看官,好久不见,甚是想念。 今天我们来聊聊Java里的一个小妖精,那就是异常。 什么是异常?什么是异常处理? 异常嘛,顾名思义就是不正常,(逃),是Java程序运行时,发生的预料之外的事情,它阻止了程序按照程序员的预期正常执行。 异常处理,应该说异常处理机制,就是专门用来制服这个小妖精的法宝。Java中的异常处理机制能让程序在异常发生时,按照代码的预先设定的异常处理逻辑,针对性地处理异常,让程序尽最大可能恢复正常并继续执行,且保持代码的清晰。 简而言之,Java异常处理就是能让我们主动迎击可能到来的异常,并将它们以圆润的方式处理掉。 还是先来看个小栗子,看看java里的异常长什么样。 public class Test { public static void main(String args[]){ int i = 0 / 0; System.out.println("i = " + i); } } 别慌别慌,不要看到红色提示就内心崩溃只想关掉IDE,来,抓紧我的手,带你看清“异常”这个磨人的小妖精的真面目(滑稽)。 代码里将0作为了分母,因此程序会发生算术异常,抛出一个异常后,如果没有任何处理,默认会终止程序,所以后面的打印内容并没有输出。在异常内容里,有说明异常类型为:java.lang.ArithmeticException,也就是算术异常,后面跟着的是异常原因: / by zero,也就是说异常出现的原因是将0作为了分母,而且后面还有堆栈信息,指出了异常抛出的位置是在com.frank.chapter16.main.Test.main这个包下,Test类的第11行(这个行数如果跟你想的不一样,不要在意,因为我的代码开始之前还有一些不可描述的说明信息),因为只有一次方法调用,所以没有很长的堆栈信息,看起来也很简洁明了。 所以你看,其实异常也没那么可怕吧,不仅给了异常原因,还告诉了你这个bug是出在第几行,所以好好利用它,可以帮助你写出更难以发现的bug,呸,说错了,可以帮助你更容易找到bug(手动滑稽)。 如果不希望抛出异常后程序就结束,而是希望它继续运行呢?那么就捕获它。 如何使用异常处理 我们来把上面那个栗子改改: public class Test { public static void main(String args[]){ try{ int i = 0 / 0; }catch (Exception e){ System.out.println("好像发生异常了,但是我不管,我还要继续运行"); } System.out.println("运行完毕!"); } } 输出如下: 好像发生异常了,但是我不管,我还要继续运行 运行完毕! 好的,很强势,现在即使抛出了异常,程序也继续运行了。异常就像是一头野兽,但你一旦捕获它,驯服它,就可以为你所用,为所欲为了。 try...catch...是常用的异常处理搭配,如果在try语句块中发生了异常,如果刚好这个异常被捕获到了,那么会直接跳到catch语句块中,执行catch语句中的代码,像上面的栗子里,因为对Exception类进行了捕获处理,所以当它的子类异常java.lang.ArithmeticException被抛出来的时候,也能捕获它。关于Exception类的结构层次关系,后面再做详细介绍。 还有另外一种搭配方式,那就是try...catch...finally,finally语句块比catch要强势的多,前面说了catch语句块必须要捕获到了特定的Exception才会执行里面的代码,如果catch的是ArithmeticException但是抛出的却是空指针异常,那就不会被捕获了,异常也就逃之夭夭了。这个时候,finally的优势就展示出来了,不管抛出什么样的异常,也不管是否抛出了异常,finally中的代码都会被执行。所以一般的用法是在finally语句块里释放掉那些需要被释放的资源,如socket连接,关闭io流,关闭数据库连接等等。也就是说一般在finally中收拾try中抛出的烂摊子,心疼一秒finally,果然能者多劳啊。 当然,try...finally这样的搭配也是ok的,需要注意的是,当try语句中发生了异常之后,在发生异常处之后的代码将不会再执行,而是跳到相应的catchu或者finally中去。 public class Test { public static void main(String args[]){ try{ int i = 0 / 0; }catch (NullPointerException e) { System.out.println("这里捕获空指针异常"); }catch (ArithmeticException e){ System.out.println("这里捕获算术异常"); }finally { System.out.println("这里是finally"); } System.out.println("运行完毕!"); } } 输出如下: 这里捕获算术异常 这里是finally 运行完毕! 在上面的代码中,catch语句块是可以同时使用多个的,第一个catch语句块捕获的是空指针异常,但由于抛出的是算术异常,所以没有捕获住,但被第二个catch捕获到了,所以第二个catch语句块中的代码执行了。异常匹配是按照从上到下的顺序进行匹配的,最后才执行finally中的代码块。关于try...catch...finally,还有一个很有趣的return问题,如果三个语句块里都有return,最终返回结果会是怎样呢?这里做了详细的说明,http://www.cnblogs.com/mfrank/p/7895660.html 有兴趣的话可以看一看。 绝大多数情况下,finally中的代码都是会被执行的,只有一种情况下,finally中的代码不会被执行,那就是在try语句块中结束掉了虚拟机(如:使用 System.exit(0); )。 关于异常,还有一个关键字需要介绍,那就是throw,使用throw可以主动抛出一个异常。看到这你也许会一脸懵逼,主动抛出???嫌异常不够多,凑热闹不嫌事大??别急别急,中间一定有什么误会,把刀放下,有话好好说。 throw关键字确实是用来抛出异常的,你可以这样使用: public class Test { public static void main(String args[]){ try{ throw new NullPointerException("听说你很闲,给你抛个异常。"); }catch (NullPointerException e) { System.out.println("这里捕获空指针异常,提示内容:" + e.getMessage()); e.printStackTrace(); } } } 输出如下: 这里捕获空指针异常,提示内容:听说你很闲,给你抛个异常。 java.lang.NullPointerException: 听说你很闲,给你抛个异常。 at com.frank.chapter16.main.Test.main(Test.java:11) 用throw关键字可以抛出任意类型的异常,当然,你想的话,还有抛Error,至于什么是Error,已经跟Exception的关系,将在下一篇里进行讲解。暂时不用深究。 在throw异常的时候,可以加上抛出异常的原因,这样可以更方便定位问题所在,当然,一般来说不会像栗子中这样使用的,这里只是为了简单起见。 到此为止,异常的上半篇已经讲解完毕,在这一篇里,说明了什么是异常,什么是异常处理,以及如何使用异常处理机制。相信大家对这个小妖精有了初步的认识,下一篇中,将会讲解Exception家族都有哪些成员,如何使用自定义异常,已经异常处理的实际使用中的正确姿势。欢迎大家继续关注,之后计划每周两篇以上的更新,如果有讲解遗漏或者不好的地方,欢迎大家及时指出,共同进步! 真正重要的东西,用眼睛是看不见的。

优秀的个人博客,低调大师

java基础学习_面向对象(下)03_day10总结

==========================================================================================================================================================涉及的知识点有: 1:方法的形式参数和方法的返回值的问题(理解) (1)方法的形式参数为引用数据类型 (2)方法的返回值类型为引用数据类型 (3)链式编程 2:包(理解) (1)包其实就是文件夹。 (2)包的作用 (3)包的定义(掌握) (4)包的注意事项(掌握) (5)带包的编译和运行 (6)Java中不同包下的类与类之间的访问 3:导包(掌握) (1)导包的原因 (2)导包的格式 (3)package,import,class有没有顺序关系呢? 4:权限修饰符(掌握) (1)权限修饰符的权限测试 (2)这四种权限修饰符在任意时刻只能出现一种。 5:类及其组成所使用的常见修饰符(理解) (1)修饰符的分类 (2)常见的类及其组成所使用的修饰符 1.修饰类的 2.修饰成员变量的 3.修饰构造方法的 4.修饰成员方法的 (3)另外比较常见的修饰符组合规则 6:内部类(理解) (1)把类定义在另一个类的内部,该类就被称为内部类。 (2)内部类的访问特点 (3)内部类的分类(内部类的位置) (4)成员内部类 (5)成员内部类的面试题(填空) (6)局部内部类 (7)匿名内部类(很重要掌握) (8)匿名内部类在开发中的使用 (9)匿名内部类的面试题(补齐代码)==========================================================================================================================================================1:方法的形式参数和方法的返回值的问题(理解) (1)方法的形式参数为引用数据类型: 1.方法的形式参数为类名时:需要该类的对象。(匿名对象的时候已经讲过了) 2.方法的形式参数为抽象类名时:需要该抽象类的子类对象。 3.方法的形式参数为接口名时:需要该接口的实现类对象。 (2)方法的返回值类型为引用数据类型: 1.方法的返回值类型为类名时:返回的是该类的对象。 2.方法的返回值类型为抽象类名时:返回的是该类的子类对象。 3.方法的返回值类型为接口名时:返回的是该接口的实现类的对象。 (3)链式编程 对象.方法1().方法2().方法3(). ……… .方法n(); 这种用法: 其实 在方法1()调用完毕后,应该一个对象; 方法2()调用完毕后,应该返回一个对象。 方法3()调用完毕后,应该返回一个对象。 ………… 方法n()调用完毕后,返回的可能是对象,也可以不是对象。-----------------------------------------------------------------------------2:包(理解) (1)包其实就是文件夹。 (2)包的作用: A:区分同名的类(即把具有相同类名的类放到不同的包中)。 B:对类进行分类管理。 a:包按照功能分 cn.itcast.add 增加功能的包 AddStudent 增加学生的类 AddTeacher 增加老师的类 cn.itcast.delete 删除功能的包 DeleteStudent 删除学生的类 DeleteTeacher 删除老师的类 cn.itcast.update 修改功能的包 UpdateStudent 修改学生的类 UpdateTeacher 修改老师的类 cn.itcast.find 查找功能的包 FindStudent 查找学生的类 FindTeacher 查找老师的类 b:包按照模块分 cn.itcast.student 学生的包 AddStudent 增加学生的类 DeleteStudent 删除学生的类 UpdateStudent 修改学生的类 FindStudent 查找学生的类 cn.itcast.teacher 老师的包 AddTeacher 增加老师的类 DeleteTeacher 删除老师的类 UpdateTeacher 修改老师的类 FindTeacher 查找老师的类 小结:开发中,两种分类方式结合使用。--------------------------------------- (3)包的定义(掌握) 定义包的格式: package 包名; 多级包用.分开。 (4)包的注意事项(掌握): A:package语句必须是程序的第一条可执行的代码。(可执行=可被虚拟机识别) B:package语句在一个java文件中只能有一个。 C:如果没有package,默认表示无包名。--------------------------------------- (5)带包的编译和运行 A:手动式 a:编写一个带包的Xxx.java文件。 例如: package cn.itcast; class HelloWorld { public static void main(String[] args) { System.out.println("HelloWorld"); } } b:通过javac命令编译该Xxx.java文件,生成对应的Xxx.class文件。 c:手动创建包名。 d:把b步骤的Xxx.class文件放到c步骤的最底层包。 e:回到和包根目录在同一目录的地方,然后带包运行。 格式:java cn.itcast.Xxx--------------------------------------- B:自动式(掌握) a:编写一个带包的Xxx.java文件。 b:javac编译的时候带上-d即可 格式:javac -d . Xxx.java c:回到和包根目录在同一目录的地方,然后带包运行 格式:java cn.itcast.Xxx--------------------------------------- (6)Java中不同包下的类与类之间的访问 ----------------------------------------------------------------------------- 3:导包(掌握) (1)导包的原因:我们多次使用一个带包的类,都需要加包的全路径非常的麻烦,这个时候,Java就提供了导包的功能,提供了一个关键字import。 (2)导包的格式: java.lang不需要导入 import xxx.yyy.类名; 这种方式导入的是:导入到类的级别。 另一种: import xxx.yyy.*;(不建议) (3)package,import,class有没有顺序关系呢? 有。 package > import > class package:只能有一个 import:可以有多个 class:可以有多个,以后建议是一个。(因为每一个类是一个独立的单元)----------------------------------------------------------------------------- 4:权限修饰符(掌握) (1)权限修饰符的权限测试 小结:protected修饰的东西其实就是给子类用的。 所以以后在设计父类的时候,可以把private修饰的成员变量用protected修饰, 这样子类中就可以使用this关键字了,比如:this.name = name; 但是其实这样的做法不是很多,还是建议用private修饰最好。--------------------------------------- (2)这四种权限修饰符在任意时刻只能出现一种。 public class Demo {} -----------------------------------------------------------------------------5:类及其组成所使用的常见修饰符(理解) (1)修饰符的分类: 权限修饰符:private、默认、protected、public 状态修饰符:static、final 抽象修饰符:abstract (2)常见的类及其组成所使用的修饰符: 1.修饰类的: 有:默认、public、final、abstract 示例如下: class Demo {} //默认修饰符 public class Demo {} final class Demo {} //最终类,不能被继承。 abstract class Demo {} //抽象类 常用类的修饰符:public class Demo {} 特别注意:静态不可以修饰外部类,但是可以修饰内部类。--------------------------------------- 2.修饰成员变量的: 有:private、默认、protected、public、static、final 示例如下: private int x = 10; int y = 20; protected int z = 30; public int a = 40; public final int b = 50; //表示自定义的常量 public static int c = 60; //表示定义的通过类名访问的变量 public static final int d = 70; //表示自定义的通过类名访问的常量 常用成员变量的修饰符:private int x = 10;--------------------------------------- 3.修饰构造方法的: 有:private、默认、protected、public 示例如下: private Demo(){} Demo(String name){} protected Demo(String name, int age) {} public Demo(String name, int age, String address) {} 常用构造方法的修饰符:public Demo(String name, int age, String address) {} 小结:构造方法只能使用权限修饰符,即构造方法只提供访问权限,不提供其他的。 --------------------------------------- 4.修饰成员方法的: 有:private、默认、protected、public、static、final、abstract 示例如下: private void show() {} void show() {} protected void show() {} public void show() {} static void show() {} //静态方法,只能通过类名访问 abstract void show(); //抽象方法 final void show() {} //最终方法 常用成员方法的修饰符:public void show() {}--------------------------------------- (3)另外比较常见的修饰符组合规则: 示例如下: 修饰成员变量的: public static final int x = 10; //定义一个静态的最终变量(常量),只能通过类名访问 修饰成员方法的: public static void show() {} public abstract void show(); public final void show() {}-----------------------------------------------------------------------------6:内部类(理解) (1)把类定义在另一个类的内部,该类就被称为内部类。 举例:把类B定义在类A中,类B就被称为内部类。 (2)内部类的访问特点: A:内部类可以直接访问外部类的成员,包括私有成员。 B:外部类要想访问内部类成员,必须创建内部类的对象,通过内部类的对象去访问。 (3)内部类的分类(内部类的位置): A:成员位置:在类中的成员位置定义的类,被称为成员内部类。 B:局部位置:在类中的局部位置定义的类,被称为局部内部类。--------------------------------------- (4)成员内部类 成员内部类的常见修饰符及应用 A:private 为了保证数据的安全性 B:static 为了方便访问数据 注意:静态的内部类访问外部类的数据时,外部类的数据必须用静态修饰。 成员内部类不被静态修饰后的访问格式是: 外部类名.内部类名 对象名 = new 外部类名.new 内部类名(); 成员内部类被静态修饰后的访问格式是: 外部类名.内部类名 对象名 = new 外部类名.内部类名();--------------------------------------- (5)成员内部类的面试题(填空) 注意: 1:内部类和外部类没有继承关系。(这样你就不会使用super去访问外部类的成员变量了) 2:通过外部类名限定this对象。 Outer.this 1 class Outer { 2 public int num = 10; 3 4 class Inner { 5 public int num = 20; 6 7 public viod show() { 8 int num = 30; 9 10 System.out.println(num); //30 11 System.out.println(this.num); //20 12 System.out.println(Outer.this.num); //10 通过外部类名限定this对象。 13 System.out.println(new Outer().num);//10 通过创建外部类对象,来调用外部类的成员变量。 14 } 15 } 16 } 17 class InnerClassTest { 18 public static void main(String[] args) { 19 Outer.Inner oi = new Outer().new Inner(); 20 oi.show(); 21 } 22 } --------------------------------------- (6)局部内部类 A:局部内部类可以直接访问外部类的成员。 B:局部内部类在局部位置可以创建内部类对象,通过内部类对象调用内部类方法,来使用局部内部类功能。 C:局部内部类访问局部变量,局部变量必须加final修饰。为什么呢? 因为局部变量会随着方法的调用完毕而消失,这个时候,局部对象并没有立马从堆内存中消失, 局部对象还要使用这个局部变量。为了让数据还能继续被使用,就用fianl修饰局部变量, 这样,在堆内存里面存储的其实是一个常量值。通过反编译工具可以看一下。 通过反编译工具我们看到了,加入final后,堆内存直接存储的是值,而不是局部变量名。--------------------------------------- (7)匿名内部类(很重要掌握) A:匿名内部类是局部内部类的简化形式。 B:匿名内部类的前提: 存在一个类或者接口。 这里的类可以是具体类也可以是抽象类。 C:格式: new 类名或者接口名() { 重写方法; } D: 匿名内部类的本质是什么呢? 答:是一个继承了该类的子类或者实现了该接口的实现类的匿名对象。 简言之:匿名内部类是一个子类的匿名对象。 再简言之:匿名内部类是子类的对象。 小结:匿名内部类是一个结合体,是子类和对象的结合体。--------------------------------------- (8)匿名内部类在开发中的使用 我们在开发的时候,会看到抽象类,或者接口作为方法的形式参数。 而这个时候,我们知道实际需要的是一个子类的对象。 如果该方法仅仅调用一次,我们就可以使用匿名内部类的格式进行简化。 Android开发中这种格式见得多, JavaEE开发中见得少。 为什么呢? 因为匿名内部类的好处是: 匿名内部类用完之后就是垃圾(即只能用一次),就可以立即被垃圾回收器回收, 栈内存没有东西指向你,Android的手机内存小,要及时让这个对象被回收。 1 interface Person { 2 public abstract void study(); 3 } 4 5 class PersonDemo { 6 public void method(Person p) { 7 p.study(); 8 } 9 } 10 11 class PersonTest { 12 public static void main(String[] args) { 13 PersonDemo pd = new PersonDemo(); 14 pd.method(new Person() { 15 public void study() { 16 System.out.println("好好学习,天天向上"); 17 } 18 }); 19 } 20 } --------------------------------------- (9)匿名内部类的面试题(补齐代码) 1 interface Inter { 2 void show(); 3 } 4 5 class Outer { 6 //补齐代码 7 public static Inter method() { 8 return new Inter() { 9 public void show() { 10 System.out.println("HelloWorld"); 11 } 12 }; 13 } 14 } 15 16 class OuterDemo { 17 public static void main(String[] args) { 18 Outer.method().show(); //"HelloWorld" 19 } 20 /* 21 1:Outer.method()可以看出method()应该是Outer中的一个静态方法。 22 2:Outer.method().show()可以看出method()方法的返回值是一个对象。 23 又由于接口Inter中有一个show()方法,所以我认为method()方法的返回值类型是一个接口。 24 */ 25 } =============================================================================我的GitHub地址: https://github.com/heizemingjun 我的博客园地址: http://www.cnblogs.com/chenmingjun 我的蚂蚁笔记博客地址: http://blog.leanote.com/chenmingjun Copyright ©2018 黑泽明军 【转载文章务必保留出处和署名,谢谢!】

优秀的个人博客,低调大师

java基础学习_面向对象(下)02_day09总结

==========================================================================================================================================================涉及的知识点有: 1:final关键字(掌握) 2:多态(掌握) 3:抽象类(掌握) 4:接口(掌握)==========================================================================================================================================================1:final关键字(掌握) (0)由于继承中方法有一个现象:方法重写。 所以,父类的功能,就会被子类给覆盖掉。 有些时候,我们不想让子类去覆盖掉父类的功能,只能调用但不能去覆盖修改。 这个时候,针对这种情况,Java就提供了一个关键字:final。--------------------------------------- (1)final是最终的意思,常见的final可以修饰类、方法、变量。 (2)fianl的特点: A:final修饰的类,不能被继承。 编译报错:无法从最终Fu进行继承 应用:最底层的那个类可以用final修饰,这样该类就不能有儿子了。(即绝育) B:final修饰的方法,不能被重写(覆盖/复写)。 编译报错:Zi中的show()无法覆盖Fu中的show() C:final修饰的变量,是一个常量,只能被赋值一次。 编译报错:无法为最终变量num2分配值 注意:被final修饰的成员变量没有默认值,必须在构造器(constructor )结束之前被赋予一个明确的值。即在定义被final修饰的成员变量时就给值。 小补充: 常量分为两种: 1.字面值常量 例如:"hello"、10、true 2.自定义常量 例如:final int x = 10;--------------------------------------- (3)final关键字面试题相关: public、private等权限修饰符会用来修饰成员变量、构造方法和成员方法。 不会用来修饰局部变量(在方法内部的变量),因为权限修饰符修饰局部变量是没有意义的,在方法内部的局部变量是被封装好的,外界的方法看不到。 final既可以修饰局部变量也可以修饰成员变量和成员方法。 A:final修饰局部变量 a:当局部变量为基本数据类型 值不能发生改变 final x = 100; b:当局部变量为引用数据类型 地址值不能发生改变,但是该对象的堆内存的内容是可以改变的。 final Student s = new Student(); s = new Student(); //对象s重新指向了新的地址值,但是对象s被final修饰了,所以这句会报错!--------------------------------------- B:final修的饰变量的初始化时机 a:被final修饰的变量只能被初始化一次(默认初始化不算哦)。 b:被final修饰的变量的初始化时机:在对象构造方法执行完毕前进行赋值就行。 注意:这个时机仅仅针对的是非静态的常量。因为静态的早早就加载了。 c:变量常见的给值时机 1.在定义的时候就给值。(推荐方式) 2.在构造代码块中给值。 3.在构造方法中给值。----------------------------------------------------------------------------- 2:多态(掌握) (1)某一个事物,在不同时刻表现出来的不同状态。 猫可以是猫的类型。 猫 m = new 猫(); 同时猫也是动物的一种,也可以把猫称为动物。 动物 d = new 猫(); 再举一个例子:水在不同时刻的状态。--------------------------------------- (2)多态的前提和体现: A:多态有继承或者实现关系。 B:多态有方法重写。(因为多态是靠方法重写来体现不同状态的) 其实没有方法重写也是可以的,但是如果没有方法重写就没有意义了。 C:多态有父类或者父接口引用指向子类对象。 即:父 f = new 子(); 多态的分类: a:具体类的多态 class Fu {} class Zi extends Fu {} Fu f = new Zi(); b:抽象类的多态 abstract class Fu {} class Zi extends Fu {} Fu f = new Zi(); c:接口的多态 interface Fu {} class Zi implements Fu {} Fu f = new Zi();--------------------------------------- (3)多态中的成员访问特点: A:对于多态中的成员变量的访问 编译看左边,运行看左边。 因为子可以访问父的成员变量,父不可以访问子的成员变量。(即:对于成员变量,可以向上访问,不可以向下访问。) B:对于多态中的构造方法的访问 创建子类对象的时候,子类的构造都会默认访问父类构造,为了对父类的数据进行初始化。 C:对于多态中的成员方法的访问 编译看左边,运行看右边。 因为成员方法有重写,父类的成员方法会被子类覆盖掉。因为成员方法是跟对象相关的。 D:对于多态中的静态方法的访问 编译看左边,运行看左边。 因为静态方法只能被静态方法重写,但是静态方法根本算不上重写。因为静态是跟类相关的。所以访问静态方法的时候是左边。 为什么? 因为成员方法有方法重写,父类的动作被子类重写掉了,所以该动作走的是儿子的。 也即对于多态中的成员方法的访问看右边(子类)。--------------------------------------- (4)多态的好处: A:提高了代码的维护性(继承体现) 因为多态有继承或者实现关系。 B:提高了代码的扩展性(多态体现) 原因如下: 猫狗案例: 注意几点: 测试类里面不能放其他东西,只能放创建的对象和通过对象调用的方法。 把构造方法私有,别人就不能创建对象了,只能通过类名来调用静态方法了。 针对动物操作的工具类中,调用动物的功能时,形参用动物类进行接收(即多态)。 即 Animal a = new Cat(); a = new Dog(); a = new Pig(); ......--------------------------------------- (5)多态的弊端: Fu f = new Zi(); 父类不能使用子类的特有功能(即成员方法)。 因为我们拿父类去访问子类,但是对于成员方法,父类只能访问在父类中定义的方法,在父类中没有定义的方法不能访问。 简言之:子可以当做父使用,父不能当做子使用。因为子比父的东西要多。 我父类就想使用子类的特有功能?行不行? 答:行。 那怎么行呢? 法一:创建子类对象调用方法即可。(可以,但是很多时候不合理。而且,重新创建对象,太占内存了。) Zi z = new Zi(); 法二:把父类的引用强制赋值给子类的引用。(向下转型)(这样做内存中只有一个对象,省内存!) 因为引用类型赋值要求类型要兼容! Zi z = (Zi)f;--------------------------------------- (6)多态中的转型问题: A:向上转型 从子到父 Fu f = new Zi(); B:向下转型 从父到子 Zi z = (Zi)f; //前提:要求该f必须是能够转换为Zi的。--------------------------------------- (7)孔子装爹的案例帮助大家理解多态 //然后就穿上爹的衣服,带上爹的眼睛,粘上爹的胡子。就开始装爹。 //其实就是向上转型。 孔子爹 k爹 = new 孔子(); //脱下爹的装备,换上自己的装备。 //其实就是向下转型。 孔子 k = (孔子)k爹; --------------------------------------- (8)多态的练习 A:猫狗案例 B:老师和学生案例-----------------------------------------------------------------------------3:抽象类(掌握) (1)抽象类的概述: 把多个共性的东西提取到一个类中,这是继承的做法。 但是呢,这多个共性的东西,在有些时候,方法声明是一样的,但是方法体不一样。 也就是说,方法声明是一样,但是每个具体的对象在具体实现的时候内容不一样。 所以,我们在定义这些共性的方法的时候,就不能给出具体的方法体。 在Java中,一个没有具体的方法体的方法应该定义为抽象方法。 而在一个类中如果有抽象方法,该类必须定义为抽象类。--------------------------------------- (2)抽象类的特点: A:抽象类和抽象方法必须用关键字abstract修饰。 格式: abstract class 类名 {} public abstract void eat(); //没有方法体。 //public abstract void eat() {} //有方法体,但方法体为空。会报错。 B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类。 C:抽象类不能实例化。 例如: abstract class Animal {} Animal a = new Animal(); //会报错,因为动物类是抽象的,不能new。 抽象类有构造方法,但是不能实例化。 那么抽象类的构造方法的作用是什么呢? 答:用于子类访问父类数据初始化。 D:抽象类的子类可能是: a:抽象类的子类可以是一个抽象类。这个子类不用重写抽象类中的抽象方法。 b:抽象类的子类可以是一个具体类(可以new对象,使用多态实例化抽象类)。但这个子类必须重写抽象类中的所有抽象方法。 E:抽象类的实例化 通过具体的子类实现的(即:多态的方式。也即:向上转型的方式),其实这也是多态的一种,叫做抽象类多态。 多态最主要的应用是在抽象类中使用,而不是在具体类中。这样抽象类对外界提供的是抽象的方法,而靠真正具体的子类来重写实现的。--------------------------------------- (3)抽象类的成员特点: A:抽象类的成员变量的特点 可以有变量 也可以有常量 B:抽象类的构造方法的特点 有构造方法,但是不能实例化。用于子类访问父类数据的初始化。 C:抽象类的成员方法的特点 可以有抽象方法 强制具体的子类必须完成某些动作。 也可以有非抽象方法 使子类继承非抽象方法,提高代码复用性。--------------------------------------- (4)抽象类的练习: A:猫狗案例练习 示例代码如下: 1 /* 2 猫狗案例练习: 3 具体事物:猫,狗 4 共性:姓名,年龄,吃饭 5 --------------------------------------- 6 分析:从具体到抽象 7 猫类: 8 成员变量:姓名,年龄 9 构造方法:无参,带参 10 成员方法:吃饭(猫吃鱼) 11 12 狗类: 13 成员变量:姓名,年龄 14 构造方法:无参,带参 15 成员方法:吃饭(狗吃肉) 16 17 因为有共性的内容,所以就提取了一个父类。动物类。 18 但是又由于吃饭的内容不一样,所以吃饭的方法是抽象的, 19 而方法是抽象的,则类就必须定义为抽象类。得到抽象动物类。 20 21 抽象动物类: 22 成员变量:姓名,年龄 23 构造方法:无参,带参 24 成员方法:吃饭(); 25 --------------------------------------- 26 实现:从抽象到具体 27 抽象动物类: 28 成员变量:姓名,年龄 29 构造方法:无参,带参 30 成员方法:吃饭(); 31 32 具体的狗类: 33 继承自抽象动物类 34 重写吃饭(); 35 36 具体的猫类: 37 继承自抽象动物类 38 重写吃饭(); 39 40 测试类: 41 */ 42 43 //定义抽象的动物类 44 abstract class Animal { 45 //姓名 46 private String name; 47 //年龄 48 private int age; 49 50 public Animal() {} 51 52 public Animal(String name, int age) { 53 this.name = name; 54 this.age = age; 55 } 56 57 public String getName() { 58 return name; 59 } 60 61 public void setName(String name) { 62 this.name = name; 63 } 64 65 public int getAge() { 66 return age; 67 } 68 69 public void setAge(int age) { 70 this.age = age; 71 } 72 73 //定义一个抽象的方法 74 public abstract void eat(); 75 } 76 77 //定义具体的狗类 78 class Dog extends Animal { 79 public Dog() {} 80 81 public Dog(String name, int age) { 82 super(name, age); 83 } 84 85 public void eat() { 86 System.out.println("狗吃肉"); 87 } 88 } 89 90 //定义具体的猫类 91 class Cat extends Animal { 92 public Cat() {} 93 94 public Cat(String name, int age) { 95 super(name, age); 96 } 97 98 public void eat() { 99 System.out.println("猫吃鱼"); 100 } 101 } 102 103 //测试类 104 class AbstractTest { 105 public static void main(String[] args) { 106 //测试狗类 107 //具体类测试 108 //方式1: 109 Dog d = new Dog(); 110 d.setName("旺财"); 111 d.setAge(3); 112 System.out.println(d.getName()+"---"+d.getAge()); 113 d.eat(); 114 //方式2: 115 Dog d2 = new Dog("旺财", 3); 116 System.out.println(d2.getName()+"---"+d2.getAge()); 117 d2.eat(); 118 System.out.println("---------------------------"); 119 120 //多态测试:因为子类中没有定义特有功能,所以可以多态实现。 121 Animal a = new Dog(); 122 a.setName("旺财"); 123 a.setAge(3); 124 System.out.println(a.getName()+"---"+a.getAge()); 125 a.eat(); 126 127 Animal a2 = new Dog("旺财", 3); 128 System.out.println(a2.getName()+"---"+a2.getAge()); 129 a2.eat(); 130 System.out.println("---------------------------"); 131 132 //练习:测试猫类 133 //具体类测试 134 //方式一: 135 Cat c = new Cat(); 136 c.setName("多啦A梦"); 137 c.setAge(5); 138 System.out.println(c.getName()+"---"+c.getAge()); 139 c.eat(); 140 //方式二: 141 Cat c2 = new Cat("哆啦A梦", 5); 142 System.out.println(c2.getName()+"---"+c2.getAge()); 143 c2.eat(); 144 System.out.println("---------------------------"); 145 146 //多态测试:因为子类中没有定义特有功能,所以可以多态实现。 147 Animal a3 = new Cat(); 148 a3.setName("哆啦A梦"); 149 a3.setAge(5); 150 System.out.println(a3.getName()+"---"+a3.getAge()); 151 a3.eat(); 152 153 Animal a4 = new Cat("哆啦A梦", 5); 154 System.out.println(a4.getName()+"---"+a4.getAge()); 155 a4.eat(); 156 157 } 158 } B:老师案例练习 示例代码如下: 1 /* 2 老师案例练习: 3 具体事物:基础班老师,就业班老师 4 共性:姓名,年龄,讲课 5 --------------------------------------- 6 分析: 7 基础班老师类 8 姓名,年龄 9 无参,带参 10 讲课(讲解JavaSE) 11 就业班老师类 12 姓名,年龄 13 无参,带参 14 讲课(讲解JavaEE) 15 抽象老师类 16 姓名,年龄 17 无参,带参 18 讲课(); 19 --------------------------------------- 20 实现: 21 抽象老师类 22 具体的基础班老师类 23 具体的就业班老师类 24 测试类 25 */ 26 27 //定义抽象的老师类 28 abstract class Teacher { 29 //姓名 30 private String name; 31 //年龄 32 private int age; 33 34 public Teacher() {} 35 36 public Teacher(String name, int age) { 37 this.name = name; 38 this.age = age; 39 } 40 41 public String getName() { 42 return name; 43 } 44 45 public void setName(String name) { 46 this.name = name; 47 } 48 49 public int getAge() { 50 return age; 51 } 52 53 public void setAge(int age) { 54 this.age = age; 55 } 56 57 //抽象方法 58 public abstract void teach(); 59 } 60 61 //具体的基础班老师类 62 class BasicTeacher extends Teacher { 63 public BasicTeacher(){} 64 65 public BasicTeacher(String name, int age) { 66 super(name, age); 67 } 68 69 public void teach() { 70 System.out.println("基础班老师讲解JavaSE"); 71 } 72 } 73 74 //具体的就业班老师类 75 class WorkTeacher extends Teacher { 76 public WorkTeacher(){} 77 78 public WorkTeacher(String name, int age) { 79 super(name, age); 80 } 81 82 public void teach() { 83 System.out.println("就业班老师讲解JavaEE"); 84 } 85 } 86 87 class AbstractTest2 { 88 public static void main(String[] args) { 89 //具体的类测试,自己玩 90 //基础班老师 91 //方式一: 92 BasicTeacher bt = new BasicTeacher(); 93 bt.setName("刘意"); 94 bt.setAge(30); 95 System.out.println(bt.getName()+"---"+bt.getAge()); 96 bt.teach(); 97 //方式二: 98 bt = new BasicTeacher("刘意", 30); 99 System.out.println(bt.getName()+"---"+bt.getAge()); 100 bt.teach(); 101 System.out.println("--------------"); 102 103 //就业班老师 104 //方式一: 105 WorkTeacher wt = new WorkTeacher(); 106 wt.setName("林青霞"); 107 wt.setAge(27); 108 System.out.println(wt.getName()+"---"+wt.getAge()); 109 wt.teach(); 110 //方式二: 111 wt = new WorkTeacher("林青霞", 27); 112 System.out.println(wt.getName()+"---"+wt.getAge()); 113 wt.teach(); 114 System.out.println("---------------"); 115 116 //多态测试:因为子类中没有定义特有功能,所以可以多态实现。 117 //基础班老师 118 Teacher t = new BasicTeacher(); 119 System.out.println(t);//BasicTeacher@6d06d69c 120 t.setName("刘意"); 121 t.setAge(30); 122 System.out.println(t.getName()+"---"+t.getAge()); 123 t.teach(); 124 System.out.println("--------------"); 125 126 //对象名没有改哦,因为这是同一个对象此时指向了别的地址。 127 t = new BasicTeacher("刘意", 30); 128 System.out.println(t);//BasicTeacher@7852e922 129 System.out.println(t.getName()+"---"+t.getAge()); 130 t.teach(); 131 System.out.println("--------------"); 132 133 //就业班老师 134 //对象名依旧没有改哦,因为这是同一个对象此时指向了别的地址。 135 t = new WorkTeacher(); 136 System.out.println(t);//WorkTeacher@4e25154f 137 t.setName("林青霞"); 138 t.setAge(27); 139 System.out.println(t.getName()+"---"+t.getAge()); 140 t.teach(); 141 System.out.println("--------------"); 142 143 //对象名依旧依旧没有改哦,因为这是同一个对象此时指向了别的地址。 144 t = new WorkTeacher("林青霞", 27); 145 System.out.println(t);//WorkTeacher@70dea4e 146 System.out.println(t.getName()+"---"+t.getAge()); 147 t.teach(); 148 } 149 } C:学生案例练习 示例代码如下:类同B,不在赘述。 D:员工案例练习 示例代码如下: 1 /* 2 假如我们在开发一个系统时需要对员工类进行设计,员工包含3个属性:姓名、工号以及工资。 3 经理也是员工,除了含有员工的属性外,另为还有一个奖金属性。 4 请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。 5 --------------------------------------- 6 分析: 7 普通员工类 8 成员变量:姓名、工号以及工资。 9 成员方法:工作 10 经理类: 11 成员变量:姓名、工号以及工资,奖金属性。 12 成员方法:工作 13 --------------------------------------- 14 实现: 15 抽象员工类 16 具体的普通员工类 17 具体的经理类 18 测试类 19 */ 20 21 //定义抽象员工类 22 abstract class Employee { 23 //姓名、工号以及工资 24 private String name; 25 private String id; 26 private int salary; 27 28 public Employee() {} 29 30 public Employee(String name, String id, int salary) { 31 this.name = name; 32 this.id = id; 33 this.salary = salary; 34 } 35 36 public String getName() { 37 return name; 38 } 39 40 public void setName(String name) { 41 this.name = name; 42 } 43 44 public String getId() { 45 return id; 46 } 47 48 public void setId(String id) { 49 this.id = id; 50 } 51 52 public int getSalary() { 53 return salary; 54 } 55 56 public void setSalary(int salary) { 57 this.salary = salary; 58 } 59 60 //工作 61 public abstract void work(); 62 } 63 64 //具体的普通员工类 65 class Programmer extends Employee { 66 public Programmer() {} 67 68 public Programmer(String name, String id, int salary) { 69 super(name, id, salary); 70 } 71 72 public void work() { 73 System.out.println("按照需求写代码"); 74 } 75 } 76 77 //具体的经理类 78 class Manager extends Employee { 79 //奖金 80 private int money; //bonus 奖金 81 82 public Manager() {} 83 84 public Manager(String name, String id, int salary, int money) { 85 super(name, id, salary); 86 this.money = money; 87 } 88 89 public void work() { 90 System.out.println("跟客户谈需求"); 91 } 92 93 public int getMoney() { 94 return money; 95 } 96 97 public void setMoney(int money) { 98 this.money = money; 99 } 100 } 101 102 //测试类 103 class AbstractTest4 { 104 public static void main(String[] args) { 105 //测试具体的普通员工类 106 Employee emp = new Programmer(); 107 emp.setName("林青霞"); 108 emp.setId("czbk001"); 109 emp.setSalary(18000); 110 System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary()); 111 emp.work(); 112 System.out.println("-------------"); 113 emp = new Programmer("林青霞", "czbk001", 18000); 114 System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary()); 115 emp.work(); 116 System.out.println("-------------"); 117 118 //测试具体的经理类 119 /* 120 emp = new Manager(); 121 emp.setName("刘意"); 122 emp.setId("czbk002"); 123 emp.setSalary(8000); 124 emp.setMoney(2000); 125 */ 126 //由于子类经理类有特有的内容-成员变量-奖金,用多态(父类)测试不合适,所以我们用具体的子类来测试。 127 Manager m = new Manager(); 128 m.setName("刘意"); 129 m.setId("czbk002"); 130 m.setSalary(8000); 131 m.setMoney(2000); 132 System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney()); 133 m.work(); 134 System.out.println("-------------"); 135 136 //通过含参构造方法赋值 137 m = new Manager("刘意", "czbk002", 8000, 2000); 138 System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney()); 139 m.work(); 140 } 141 } --------------------------------------- (5)抽象类的几个小问题 A:抽象类有构造方法,但是抽象类不能实例化,那么构造方法有什么用? 答:用于子类访问父类数据的初始化。 B:一个类如果没有抽象方法,却定义为抽象类,有什么用? 答:为了不让外界创建该抽象类的对象,要想访问它只能通过该抽象类的子类。 C:abstract不能和哪些关键字共存? a:final 冲突 因为最终方法不能被重写,而抽象的方法需要被具体的子类重写。 final abstract void show(); //错误: 非法的修饰符组合: abstract和private b:private 冲突 因为私有方法不能被继承,所以就不能被重写,而抽象的方法需要被具体的子类重写。 private abstract void show(); //错误: 非法的修饰符组合: abstract和final c:static 无意义 因为抽象方法是没有方法体的,而静态是可以直接通过类名访问的。访问一个没有方法体的方法,意义何在呢? static abstract void show(); //错误: 非法的修饰符组合: abstract和static-----------------------------------------------------------------------------4:接口(掌握) (1)回顾猫狗案例,它们仅仅提供一些基本功能。 部分的猫会钻火圈,狗会跳高等功能,不是动物本身就具备的, 是在后面的培养中训练出来的,所以,为了体现事物功能的扩展性, Java中就提供了接口来定义这些额外功能,并不给出具体实现(说明是抽象方法),将来哪些猫狗需要被培训,只需要这部分猫狗把这些额外功能实现即可。 其实接口是最最抽象的抽象类。--------------------------------------- (2)接口的特点: A:接口用关键字interface修饰 interface 接口名 {} B:类实现接口用implements修饰 class 类名 implements 接口名 {} C:接口不能实例化 那么,接口如何实例化呢? 按照多态的方式来实例化。(即就要去做一个具体的子类,通过具体的子类去实例化) 由此可见,多态有几种方式: 1.具体类多态(几乎没有,但是讲解是通过具体类讲解的) 2.抽象类多态(常用) 3.接口多态(最常用) D:接口的实现类(子类) 接口的实现类格式:接口名+Impl a:接口的实现类是一个抽象类。但是意义不大,因为你是抽象类,最终还得需要具体子类。 //定义动物培训接口 interface AnimalTrain { public abstract void jump(); } //抽象类实现接口 abstract class Dog implements AnimalTrain { } b:接口的实现类是一个具体类,这个类必须重写接口中的所有抽象方法。(推荐方案) //定义动物培训接口 interface AnimalTrain { public abstract void jump(); } //具体类实现接口 class Cat implements AnimalTrain { public void jump() { System.out.println("猫可以跳高了"); } }--------------------------------------- (3)接口的成员特点: A:接口的成员变量特点: 只能是常量,并且是静态的。 因为接口的所有成员变量的默认修饰符都是:public static final 建议自己手动给出。 B:接口的构造方法特点: 接口没有构造方法 。 那么接口的实现类的无参构造方法默认访问的是谁的无参构造呢? 答:所有的类都默认继承一个类:Object类。 因为:类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。 又因为:类 Object 只有无参构造方法,所以后来要求所有子类都默认调用的是父类的无参构造方法。 //接口名+Impl这种格式是接口的实现类格式 /* class InterImpl implements Inter { public InterImpl() { super(); } } */ //上面的写法等价于下面的写法 class InterImpl extends Object implements Inter { public InterImpl() { super(); } } C:接口的成员方法特点: 接口的成员方法只能是抽象的。 因为接口的所有成员方法的默认修饰符都是:public abstract 建议自己手动给出。--------------------------------------- (4)类与类、类与接口、接口与接口的关系 A:类与类的关系 继承关系,只能单继承,不能多继承(只有一个父类),可以多层继承(可以有爷爷)。 class Son extends Father {} //正确 class Son extends Father, Mother {} //错误 B:类与接口的关系 1.实现关系,可以单实现,也可以多实现。(可以多扩展嘛) 2.还可以在继承一个类的同时,实现多个接口。(继承类 Object 嘛) class Son implements Father, Mother {} //正确 class Son extends Object implements Father, Mother {} //正确 C:接口与接口的关系 继承关系,可以单继承,也可以多继承。 小结:Java中的类是单继承的,Java中的接口可以多继承。--------------------------------------- (5)抽象类和接口的区别(自己补齐)? A:成员区别 抽象类: 成员变量:可以有变量,也可以有常量 构造方法:有(用于子类访问父类数据的初始化) 成员方法:可以有抽象方法,也可以有非抽象方法 接口: 成员变量:只可以是常量 构造方法:无 成员方法:只可以是抽象方法 B:关系区别: 类与类: 继承关系,只能单继承和多层继承。 类与接口: 实现关系,可以单实现,也可以多实现。 接口与接口: 继承关系,可以单继承,也可以多继承。 C:设计理念不同 抽象类 被继承体现的是:“is a”的关系,抽象类中定义的是共性功能。 接口 被实现体现的是:“like a”的关系,接口中定义的是扩展功能。--------------------------------------- (6)接口练习: A:猫狗案例,加入跳高功能 共有六个类:(这里将接口理解为最最抽象的类) 跳高接口 动物类 猫类 狗类 有跳高功能的猫类 有跳高功能的狗类 测试类 示例代码如下: 1 /* 2 猫狗案例,加入跳高的额外功能 3 --------------------------------------- 4 分析:从具体到抽象 5 猫类: 6 姓名,年龄 7 吃饭,睡觉 8 狗类: 9 姓名,年龄 10 吃饭,睡觉 11 12 由于有共性功能,所以,我们抽取出一个父类, 13 抽象动物类: 14 姓名,年龄 15 吃饭(); 16 睡觉(){} 17 18 猫类:继承自抽象动物类 19 狗类:继承自抽象动物类 20 21 跳高的额外功能是一个新的扩展功能,所以我们要定义一个接口。 22 接口: 23 跳高 24 25 部分猫类:实现跳高 26 部分狗类:实现跳高 27 --------------------------------------- 28 实现;从抽象到具体 29 跳高接口 30 抽象动物类 31 抽象猫类 32 抽象狗类 33 具体的有跳高功能的猫类 34 具体的有跳高功能的狗类 35 测试类 36 37 使用: 38 使用具有跳高功能的具体类进行测试,因为具有跳高功能的具体类具有最多的功能。 39 */ 40 //定义跳高接口 41 interface Jumpping { 42 //跳高功能 43 public abstract void jump(); 44 } 45 46 //定义抽象动物类 47 abstract class Animal { 48 //姓名 49 private String name; 50 //年龄 51 private int age; 52 53 public Animal() {} 54 55 public Animal(String name, int age) { 56 this.name = name; 57 this.age = age; 58 } 59 60 public String getName() { 61 return name; 62 } 63 64 public void setName(String name) { 65 this.name = name; 66 } 67 68 public int getAge() { 69 return age; 70 } 71 72 public void setAge(int age) { 73 this.age = age; 74 } 75 76 //吃饭(); 77 public abstract void eat(); 78 79 //睡觉(){} 80 public void sleep() { 81 System.out.println("睡觉觉了"); 82 } 83 } 84 85 //具体的猫类 86 class Cat extends Animal { 87 public Cat() {} 88 89 public Cat(String name,int age) { 90 super(name, age); 91 } 92 93 public void eat() { 94 System.out.println("猫吃鱼"); 95 } 96 } 97 98 //具体的狗类 99 class Dog extends Animal { 100 public Dog() {} 101 102 public Dog(String name, int age) { 103 super(name, age); 104 } 105 106 public void eat() { 107 System.out.println("狗吃肉"); 108 } 109 } 110 111 //有跳高功能的具体的猫类 112 class JumpCat extends Cat implements Jumpping { 113 public JumpCat() {} 114 115 public JumpCat(String name, int age) { 116 super(name,age); 117 } 118 119 public void jump() { 120 System.out.println("跳高猫"); 121 } 122 } 123 124 //有跳高功能的具体的狗类 125 class JumpDog extends Dog implements Jumpping { 126 public JumpDog() {} 127 128 public JumpDog(String name, int age) { 129 super(name,age); 130 } 131 132 public void jump() { 133 System.out.println("跳高狗"); 134 } 135 } 136 137 //测试类 138 class InterfaceTest { 139 public static void main(String[] args) { 140 //定义有跳高功能的具体的猫类并测试 141 //法一: 142 JumpCat jc = new JumpCat(); 143 jc.setName("哆啦A梦"); 144 jc.setAge(3); 145 System.out.println(jc.getName()+"---"+jc.getAge()); 146 jc.eat(); 147 jc.sleep(); 148 jc.jump(); 149 150 //法二: 151 JumpCat jc2 = new JumpCat("加菲猫", 2); 152 System.out.println(jc2.getName()+"---"+jc2.getAge()); 153 jc2.eat(); 154 jc2.sleep(); 155 jc2.jump(); 156 System.out.println("-----------------"); 157 158 //定义有跳高功能的具体的狗类并测试 159 //法一: 160 JumpDog jd = new JumpDog(); 161 jd.setName("旺财"); 162 jd.setAge(8); 163 System.out.println(jd.getName()+"---"+jd.getAge()); 164 jd.eat(); 165 jd.sleep(); 166 jd.jump(); 167 168 //法二: 169 jd = new JumpDog("旺财", 8); 170 System.out.println(jd.getName()+"---"+jd.getAge()); 171 jd.eat(); 172 jd.sleep(); 173 jd.jump(); 174 } 175 } B:老师和学生案例,加入抽烟功能 共有六个类:(这里将接口理解为最最抽象的类) 抽烟接口 人类 学生类 老师类 有抽功能的学生类 有抽功能的老师类 测试类 示例代码同上,不在赘述! =============================================================================我的GitHub地址: https://github.com/heizemingjun 我的博客园地址: http://www.cnblogs.com/chenmingjun 我的蚂蚁笔记博客地址: http://blog.leanote.com/chenmingjun Copyright ©2018 黑泽明军 【转载文章务必保留出处和署名,谢谢!】

优秀的个人博客,低调大师

java基础学习_面向对象(下)01_day08总结

==========================================================================================================================================================涉及到的知识点有:1:继承(掌握) (0)Java继承概述 (1)继承定义 (2)Java中如何表示继承呢?格式是什么呢? (3)继承的好处 (4)继承的弊端 A:让类的耦合性增强。这样某个类的改变,就会影响其他和该类相关的类。 B:打破了封装性。 (5)Java中继承的特点 (6)继承的注意事项 A:Java中类只支持单继承,不支持多继承。 B:Java中可以多层(重)继承(继承体系) (7)那么什么时候使用继承呢? A:继承体现的是:is a的关系。 B:采用假设法。 (8)Java继承中的成员关系 A:成员变量 B:构造方法 C:成员方法 (9)方法重写:(方法=成员方法) (10)方法重写的两个面试题 A:Override和Overload的区别?Overload是否可以改变返回值类型? B:this和super的区别和各自的作用? (11)数据初始化的面试题 A:一个类的初始化过程 B:子父类的构造执行过程 C:子父类的初始化(分层初始化) (12)继承案例 A:学生和老师案例 B:猫狗案例的分析和实现==========================================================================================================================================================1:继承(掌握) (0)Java继承概述 (1)继承定义:把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系,这多个类就具备了这些内容。这个关系叫继承。 (2)Java中如何表示继承呢?格式是什么呢? A:用关键字extends表示。 B:格式: class 子类名 extends 父类名 {}--------------------------------------- (3)继承的好处: A:提高了代码的复用性。 B:提高了代码的维护性。 C:让类与类之间产生了一个关系,是多态的前提。 类与类产生了关系,其实也是继承的一个弊端: 类的耦合性增强了。--------------------------------------- (4)继承的弊端: A:让类的耦合性增强。这样某个类的改变,就会影响其他和该类相关的类。 开发设计的原则:低耦合,高内聚。 耦合:类与类之间的关系。 内聚:自己完成某件事情的能力。 B:打破了封装性。 因为我们曾经说过:一个类中的成员尽量不要让外界直接访问,子类继承父类后,那么父类的封装就被打破了。--------------------------------------- (5)Java中继承的特点: A:Java中类只支持单继承,不支持多继承。 即:一个类只能有一个父类,不可以有多个父类。 class Father {} class Mother {} class Son exnteds Father {} //正确的 class Son extends Father,Mother {} //错误的 有些语言是支持多继承的额,比如c++。其格式是:extends 类1,类2,... B:Java中可以多层(重)继承(继承体系) class A {} class B extends A {} class C extends B {}--------------------------------------- (6)继承的注意事项: A:子类不能继承父类的私有成员(成员变量和成员方法)。 其实这也体现了继承的另一个弊端:打破了封装性。 因为我们曾经说过:一个类中的成员尽量不要让外界直接访问,子类继承父类后,那么父类的封装就被打破了。 B:子类不能继承父类的构造方法,但是可以通过super关键字去访问父类构造方法。 因为构造方法比较特殊,谈不上继承,构造方法是对对象进行数据初始化的。 C:不要为了部分功能而去继承。 例如: class A { public void show1(){} public void show2(){} } class B { public void show2(){} public void show3(){} } //我们发现B类中出现了和A类一样的show2()方法,所以,我们就用继承来体现。 class B extends A { public void show3(){} } 这样其实不好,因为这样你不但有了show2(),而且还多了show1()。 有可能show1()不是你想要的。--------------------------------------- (7)那么什么时候使用继承呢? A:继承体现的是:is a的关系。 例如: Person Student Teacher 水果 苹果 香蕉 橘子 B:采用假设法。 假设有两个类A,B。只有他们符合A是B的一种,或者B是A的一种的时候,就可以考虑使用继承。--------------------------------------- (8)Java继承中的成员关系: A:成员变量 a:子类的成员变量名称和父类中的成员变量名称不一样时,这个太简单。 b:子类的成员变量名称和父类中的成员变量名称一样时,这个怎么访问呢? 在子类的方法中访问一个成员变量的查找顺序: 1.在子类方法的局部范围找,有就使用。 2.在子类的成员范围找,有就使用。 3.在父类的成员范围找,有就使用。 4.都找不到,就报错。 B:构造方法 a:子类的所有的构造方法默认都会去访问父类的无参构造方法。 因为子类会继承父类中的数据,可能还会使用父类的数据。 所以,子类初始化之前,一定要先完成父类数据的初始化。 特别注意:其实子类的每一个构造方法的第一条语句默认都是:super(); b:父类中如果没有无参构造方法(也即父类中只给了带参构造方法),子类的构造方法怎么办? 法1:子类的构造方法通过 super(...); 去显示调用父类的带参构造方法。 法2:子类的构造方法通过 this();/this(...); 调用本类的其他的构造方法,但是子类的其他的构造方法中一定会有一个去访问了父类的带参构造方法。 法3:让父类提供无参构造。 注意事项: this();/this(...);/super(...); 这三个语句访问子类或父类的构造方法的时候,必须放在第一句语句上。 否则,就可能会对父类数据进行多次初始化。 C:成员方法 a:子类的成员方法名称和父类中的成员方法名称不一样时,这个太简单。 b:子类的成员方法名称和父类中的成员方法名称一样时,这个怎么访问呢? 通过子类对象访问一个成员方法的查找顺序: 1.在子类的成员方法中找,有就使用。 2.在父类的成员方法中找,有就使用。 3.都找不到,就报错。--------------------------------------- (9)方法重写:(方法=成员方法) 方法重写:子类中出现了和父类中方法声明一模一样的方法(方法名、参数列表和返回值类型都一样),也被称为方法覆盖、方法复写。 方法重载:本类中出现的方法名一样,参数列表不同,与返回值类型无关的方法。 方法重写的使用特点: 如果子类和父类的方法名不同,就调用各自对应的方法。 如果子类和父类的方法名相同,最终使用的是子类自己的方法。 方法重写的应用: 当子类需要父类的功能,而功能的主体子类还有自己特有的内容时,可以重写父类中的方法,这样,即沿袭了父类的功能,又定义了子类自己特有的内容。 方法重写的注意事项: 1.父类中的私有方法不能被重写。 因为父类私有方法子类根本无法继承。 2.子类重写父类方法时,访问权限不能更低。(最好权限要一致。) 默认的权限要小于public的权限。 3.父类的静态方法,子类也必须通过静态方法进行重写。 (其实这个算不上方法重写,但是现象确实如此,至于为什么算不上方法重写,多态中我会讲解。) 因为方法是跟对象相关的,而静态是跟类相关的。 小结:子类重写父类方法的时候,最好声明一模一样。--------------------------------------- (10)方法重写的两个面试题: A:Override和Overload的区别?Overload是否可以改变返回值类型? 方法重写: 在子类中,出现和父类中一模一样的方法声明的现象。(包含方法名、参数列表和返回值类型都一样) 方法重载: 同一个类中,出现的方法名相同,参数列表不同,与返回值类型无关的现象。 方法重载能改变返回值类型,因为它和返回值类型无关。 Override:方法重写 Overload:方法重载 B:this和super的区别和各自的作用? this: 代表当前类的对象引用。 super:代表父类存储空间的标识。(可以理解为父类的引用,通过这个东西可以访问父类的成员。) 应用场景: 成员变量: this.成员变量 super.成员变量 构造方法: this(...) super(...) 成员方法: this.成员方法 super.成员方法--------------------------------------- (11)数据初始化的面试题 A:一个类的初始化过程 先进行成员变量的初始化: 默认初始化 显示初始化 构造方法初始化 B:子父类的构造方法发的执行过程 子类的所有的构造方法默认都会去访问父类的无参构造方法。 C:子父类的初始化(分层初始化) 先进行父类初始化,然后进行子类初始化。--------------------------------------- (12)继承案例: A:学生和老师案例 继承前案例 继承后案例 B:猫狗案例的分析和实现 做设计的时候,先找到具体的事物,然后发现具体的事物的共性,再提取出一个父类。=============================================================================我的GitHub地址: https://github.com/heizemingjun 我的博客园地址: http://www.cnblogs.com/chenmingjun 我的蚂蚁笔记博客地址: http://blog.leanote.com/chenmingjun Copyright ©2018 黑泽明军 【转载文章务必保留出处和署名,谢谢!】

优秀的个人博客,低调大师

java基础学习_面向对象(上)03_day08总结

==========================================================================================================================================================涉及到的知识点有: 0:前面学习通过方法对代码进行改进,为什么要给方法使用静态呢? 1:Java如何制作帮助文档(API)(了解) 2:通过JDK提供的帮助文档(API)学习了Math类(掌握) 3:Java中的代码块(理解)==========================================================================================================================================================0:前面学习通过方法对代码进行改进,为什么要给方法使用静态呢? 答:因为main方法是静态的,而静态方法只能访问静态的成员变量和静态的成员方法。 所以之前我们的方法是使用静态来修饰的,即静态的方法。 如果我们把static去掉呢?即该如何调用非静态的方法呢? 答:通过创建对象,使用对象进行调用啊! 测试类的作用是什么? 答:创建其他类的对象,调用其他类的功能。 在同一个文件夹下,Java的类定义在两个文件中和定义在一个文件中其实是一样的。--------------------------------------- 工具类中的方法使用静态修饰后,又让外界不能通过创建对象方式去访问该方法,只能通过工具类名来访问该方法,该如何办呢? 答:把工具类中的构造方法私有即可。 如下图所示01: -----------------------------------------------------------------------------1:Java如何制作帮助文档(API)(了解) 步骤如下: (1)写一个工具类 (2)对这个类加入文档注释 (3)用工具解析文档注释 javadoc工具 (4)格式 javadoc -d 目录 -author -version ArrayTool.java 制作帮助文档(API)出错问题解决: 找不到可以文档化的公共或受保护的类 这句话告诉我们对想要操作的类的权限不够。在类前面加上public即可。 如下图所示02: --------------------------------------- 将来做开发的时候,我们给别人的东西就是Xxx.class文件和帮助文档(API)。别人通过帮助文档(API)来使用Xxx.class文件。 这就是面向对象思想,我才不管你是怎们实现的呢!我满足你的条件会用就可以。-----------------------------------------------------------------------------2:通过JDK提供的帮助文档(API)学习了Math类(掌握) (1)API(Application Programming Interface) 应用程序编程接口(帮助文档) (2)如何使用帮助文档(API)呢? 1:打开帮助文档 2:点击显示,找到索引,看到输入框 3:知道你要找谁?以Scanner举例 4:在输入框里面输入Scanner,然后回车 5:第一步:看包 java.lang包下的类不需要导入,其他的全部需要导入。 要导入: java.util.Scanner 6:再简单的看看该类的解释说明和例子,别忘了看看该类的版本。 7:看类的结构: 成员变量 字段摘要 构造方法 构造方法摘要 成员方法 方法摘要 8:学习构造方法的两种情况: A:有构造方法 就创建该类的对象,通过对象调用。 B:没有构造方法 该类的成员变量和成员方法可能都是静态的,通过类名调用。 9:看成员方法: A:看左边 看是否是静态的成员方法:如果是静态,可以通过类名调用。 看返回值类型:人家返回什么,你就用什么接收。 B:看右边 看方法名:方法名称不要写错了。 看参数列表:人家要什么参数,你就给什么参数;人家要几个参数,你就给几个参数。 (3)API中的Math类的示范使用 A:是针对数学执行基本运算进行操作的类。 B:没有构造方法,因为它的成员都是静态的。 C:产生随机数: public static double random() 返回值为double的正值,大于等于0.0 ,小于1.0。即:[0.0, 1.0) 返回的值是从该范围(大约)均匀分布的伪随机选择的。 D:如何产生一个1~100([1, 100])之间的随机数? int number = (int)(Math.random() * 100) + 1; E:猜数字小游戏。-----------------------------------------------------------------------------3:Java中的代码块(理解) (1)在Java中用{}括起来的代码。 (2)代码块分类:(根据其位置和声明的不同) A:局部代码块 在方法定义中,用于限定变量的生命周期,及早释放,提高内存利用率。 B:构造代码块 在类中方法外出现(即在类中的成员位置),可以把多个构造方法方法中相同的代码存放到一起,用于对对象进行初始化,每次调用构造方法都执行,并且在构造方法前执行。 C:静态代码块 在类中方法外出现(即在类中的成员位置),并加上static修饰,用于对类进行初始化,静态在类加载的时候就执行了,并且只执行一次。 D:同步代码块 多线程部分讲解。 (3)面试题: 静态代码块、构造代码块、构造方法的执行顺序问题? 静态代码块 > 构造代码块 > 构造方法 只执行一次 每次调用构造方法都执行 (4)代码块练习题: 看代码写程序的执行结果。============================================================================= 我的GitHub地址: https://github.com/heizemingjun 我的博客园地址: http://www.cnblogs.com/chenmingjun 我的蚂蚁笔记博客地址: http://blog.leanote.com/chenmingjun Copyright ©2018 黑泽明军 【转载文章务必保留出处和署名,谢谢!】

优秀的个人博客,低调大师

java基础学习_面向对象(上)02_day07总结

========================================================================================================================================================== 涉及到的知识点有: 1:成员变量和局部变量的区别(理解) 2:类作为形式参数的问题?(理解) 3:匿名对象(理解) 4:封装(理解) 5:private关键字(掌握) 6:this关键字(掌握) 7:构造方法(掌握) (1)作用 (2)格式 (3)构造方法的注意事项 (4)给成员变量赋值的方式有两种 (5)输出成员变量值的方式有两种 (6)标准学生案例 8:类的初始化过程代码:Student s = new Student();做了哪些事情?(理解) 9:面向对象的练习题(掌握) (1)标准的手机类的定义和手机测试类。 (2)Demo类中有求和方法,Test类进行测试。 (3)长方形案例。 (4)员工案例。 (5)MyMath案例(自己提供加减乘除并测试)。 10:static关键字(理解) (0) 针对多个对象有共同的成员变量的时候 (1)静态的意思,可以修饰成员变量和成员方法 (2)静态的特点 (3)静态的内存图 (4)静态的注意事项 (5)静态变量和成员变量的区别 (6)main方法是静态的解释 ==========================================================================================================================================================1:成员变量和局部变量的区别(理解) (1)在类中的位置不同: 成员变量:在类中方法外。 局部变量:在方法定义中或者方法声明上(即形参)。 (2)在内存中的位置不同: 成员变量:在堆中。 局部变量:在栈中。 (3)生命周期不同: 成员变量:随着对象的创建而存在,随着对象的消失而消失。 局部变量:随着方法的调用而存在,随着方法的调用完毕而消失。 (4)初始化值不同: 成员变量:有默认值。 局部变量:没有默认值,必须定义,赋值,然后才能使用。 (5)注意事项: 1.局部变量名称可以和成员变量名称一样,但是在方法中使用该变量的时候,采用的是就近原则(即先找小范围,再找大范围)。 2.局部变量前不能放置任何访问修饰符 (private,public和protected)。final可以用来修饰局部变量。被final修饰的局部变量变为常量了。 3.修饰成员变量的修饰符有:private、默认、protected、public、static、final。 ----------------------------------------------------------------------------- 2:类作为形式参数的问题?(理解) (0)之前学的形式参数问题: 基本数据类型(数值型、字符型、布尔型):形式参数的改变不影响实际参数。 引用数据类型(类、接口、数组):形式参数的改变会直接影响实际参数。 (1)如果一个方法的形参的数据类型是一个类时(即引用数据类型),这里的形参其实需要的是该类的一个具体的对象。 如下图所示01: -----------------------------------------------------------------------------3:匿名对象(理解) (1)就是没有名字的对象(是对象的一种简化表示形式)。 (2)匿名对象的应用场景: A:对象调用方法仅仅一次的时候。 注意:调用多次对象的时候,不适合。 那么,这种匿名对象调用方法有什么好处吗? 有,匿名对象调用方法完毕后就是垃圾。可以被垃圾回收器回收,提高内存使用效率。 B:匿名对象可以作为实际参数进行传递。 如下图所示02: ----------------------------------------------------------------------------- 4:封装(理解) (1)是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。 (2)好处: A:隐藏实现细节,提供公共的访问方式。 B:提高了代码的复用性。 C:提高了代码的安全性。 (3)设计原则 把不想让外界知道的实现细节给隐藏起来,把属性隐藏,提供公共的访问方式。 (4)private是封装的一种体现之一。 封装体有这几个: (1)类 (2)方法 (3)private修饰成员变量-----------------------------------------------------------------------------5:private关键字(掌握) (0)是一个权限修饰符。 (1)私有的意义,可以修饰成员变量和成员方法。(一般来说,private多用来修饰成员变量,少用来修饰成员方法。) (2)特点: 被private修饰的成员只能在本类中被访问。要想访问它,它就要对外提供公共的访问方式。 (3)private的应用: 以后再写一个类的时候: 把所有的成员变量给private了。 提供对应的getXxx()/setXxx()方法。-----------------------------------------------------------------------------6:this关键字(掌握) (0)name = name; //把自己赋值给自己,没有任何意义。(变量的使用规则:就近原则) (1)代表当前类的引用对象。简单的记,它就代表当前类的一个具体对象。 记住:哪个对象调用方法,在该方法内部的this就代表哪个对象。 (2)this的应用场景: A:解决了局部变量隐藏成员变量的问题。 B:其实this还有其他的应用,其他用法后面和super一起讲解。 如下图所示03/04: -----------------------------------------------------------------------------7:构造方法(掌握) (1)作用:用于给创建的对象的数据进行初始化。 (2)格式: A:方法名和类名相同。 B:没有返回值类型,连void都不能有。 C:没有具体的返回值。 思考题:构造方法中可不可以有return语句呢? 可以。而是我们写成这个样子就OK了:return; 其实,在任何的void类型的成员方法的最后你都可以写上:return; 表示结束该方法。 (3)构造方法的注意事项: A:如果我们没有给出构造方法,系统将自动提供一个无参构造方法,且是不带修饰符的,即默认修饰符的。 B:如果我们给出了构造方法,不管我们给出的是无参还是有参构造函数,系统将不再提供默认的无参构造方法。 注意:当我们给出了有参构造函数时,但如果我们还想使用无参构造方法,此时就必须自己给出无参构造函数。建议永远自己给出无参构造方法。 C:构造方法也是方法,也可以方法重载的。 (4)给成员变量赋值的方式有两种:(只写一种即可) 方式1:setXxx(参数类型 成员变量名)的成员方法(实际开发时用方式1,该方式更灵活。) 方式2:带一个或者多个参数的构造方法(讲课时用方式2) (5)输出成员变量值的方式有两种:(只写一种即可) 方式1:getXxx() {...}(实际开发时用方式1,该方式更灵活。) 方式2:通过调用show()方法实现(其实方式2一般没有,感觉调用getXxx()输出学生信息比较麻烦,加入一个方法show(),输出学生对象的成员变量信息。) (6)标准学生案例: 类的组成有:成员变量、构造方法、成员方法。 构造方法:没有返回值。 但是也可以在最后写一个return; 其实在任何返回值为void类型的成员方法的最后都可以写上:return; 表示结束该方法。 成员方法的分类: 根据返回值类型可以分为: 1.void类型的成员方法。 2.非void类型的成员方法。 根据形式参数可以分为: 1.无参成员方法 2.有参成员方法--------------------------------------- 1 //学生类 2 class Student { 3 private String name; 4 private int age; 5 6 //无参构造方法 7 public Student() { 8 } 9 10 //有多个参数的构造方法 11 public Student(String name,int age) { 12 this.name = name; 13 this.age = age; 14 } 15 16 //有明确返回值的、无参的成员方法(单独获取数据)。 17 public String getName() { 18 return name; 19 } 20 //返回void类型的、有参的成员方法。 21 public void setName(String name) { 22 this.name = name; 23 } 24 25 //有明确返回值的、无参的成员方法(单独获取数据)。 26 public int getAge() { 27 return age; 28 } 29 30 //返回void类型的、有参的成员方法。 31 public void setAge(int age) { 32 this.age = age; 33 } 34 35 //输出所有成员变量的值(集体获取数据) 36 public void show() { 37 system.out.println(name+"---"+age); 38 } 39 } 40 41 //学生测试类 42 class StudentDemo { 43 public static void main(String[] args) { 44 //方式1 45 Student s1 = new Student(); 46 s1.setName("林青霞"); 47 s1.setAge(27); 48 System.out.println(s1.getName()+"---"+s1.getAge()); 49 s1.show(); 50 51 //方式2 52 Student s2 = new Student("刘意",30); 53 System.out.println(s2.getName()+"---"+s2.getAge()); 54 s2.show(); 55 } 56 } ----------------------------------------------------------------------------- 8:类的初始化过程代码:Student s = new Student();做了哪些事情?(理解) (1)把Student.class文件加载到内存,在Student.class文件中找到main方法并放到栈。 (2)在栈内存为s开辟空间(Student s =)。 (3)在堆内存为学生对象申请空间(new Student();)。 (4)给学生的成员变量进行默认初始化。namne = null; age = 0; (5)给学生的成员变量进行显示初始化。name = 林青霞; age = 27; (6)通过构造方法给成员变量进行初始化。name = 刘意; age =30; (7)学生对象初始化完毕后,,把堆内存的地址赋值给栈内存的s变量。--------------------------------------- 1 class Student { 2 private String name = "林青霞"; 3 private int age = 27; 4 5 public Student() { 6 name = "刘意"; 7 age = 30; 8 } 9 } 10 11 class StudentDemo { 12 public static void main(String[] args) { 13 Student s = new Student(); 14 } 15 } 如下图所示05: ----------------------------------------------------------------------------- 9:面向对象的练习题(掌握) (1)标准的手机类的定义和手机测试类。 (2)Demo类中有求和方法,Test类进行测试。 什么时候定义成员变量? 答:当该变量是用来描述一个类的时候。---------------------------------------示例代码如下: 1 /* 2 定义一个类Demo,其中定义一个求两个数据和的方法, 3 定义一个测试类Test,进行测试。 4 5 变量什么时候定义为成员变量? 6 答:如果这个变量是用来描述这个类的信息的,那么,该变量就应该定义为成员变量。 7 8 变量到底定义在哪里好呢? 9 答:变量的范围是越小越好。因为能及时的被回收。 10 */ 11 //方式1 12 /* 13 class Demo { 14 public int sum() { 15 int a = 10; 16 int b = 20; 17 int c = a + b; 18 return c; 19 } 20 } 21 */ 22 //方式1满足了我们的要求,但是不好。 23 //因为参与操作的数据现在是固定的。 24 25 //方式2 26 /* 27 class Demo { 28 public int sum(int a,int b) { 29 return a + b; 30 } 31 } 32 */ 33 //方式2可以满足我们的要求,但是呢我们学习过来面向对象的思想。 34 //我就再想,a,b可不可以定义为成员变量呢? 35 //如果可以,我们再改进一版如下: 36 37 //方式3 38 class Demo { 39 int a; 40 int b; 41 42 public int sum() { 43 return a + b; 44 } 45 } 46 //虽然这种方式可以,并且好像是符合了面向对象的思想。 47 //但是不好。 48 //因为我们曾经说过:类是一组相关的属性和行为的集合。 49 //并且类是由事物转换过来的,而类中的成员变量就是事物的属性,属性是用来描述事物的。 50 //同理:成员变量其实是用来描述类的。 51 52 //测试类 53 class Test { 54 public static void main(String[] args) { 55 //创建对象 56 //方式1测试 57 /* 58 Demo d = new Demo(); 59 System.out.println(d.sum()); 60 */ 61 62 //方式2测试 63 /* 64 Demo d = new Demo(); 65 int a = 10; 66 int b = 20; 67 System.out.println(d.sum(a,b)); 68 */ 69 70 //方式3测试 71 Demo d = new Demo(); 72 d.a = 10; 73 d.b = 20; 74 System.out.println(d.sum()); 75 } 76 } --------------------------------------- (3)长方形案例。---------------------------------------示例代码如下: 1 /* 2 定义一个长方形类,定义求周长和面积的方法, 3 然后定义一个测试类Test2,进行测试。 4 5 长方形的类: 6 有成员变量: 7 长,宽 8 有成员方法: 9 求周长:(长+宽)*2; 10 求面积:长*宽 11 12 注意: 13 import必须出现在所有的class前面。 14 */ 15 16 import java.util.Scanner; 17 18 class ChangFangXing { 19 //长方形的长 20 private int length; 21 //长方形的宽 22 private int width; 23 24 //无参构造方法 25 public ChangFangXing(){} 26 27 //仅仅提供setXxx()即可 28 public void setLength(int length) { 29 this.length = length; 30 } 31 32 public void setWidth(int width) { 33 this.width = width; 34 } 35 36 //求周长 37 public int getZhouChang() { 38 return (length + width) * 2; 39 } 40 41 //求面积 42 public int getArea() { 43 return length * width; 44 } 45 } 46 47 class Test2 { 48 public static void main(String[] args) { 49 //创建键盘录入对象 50 Scanner sc = new Scanner(System.in); 51 52 System.out.println("请输入长方形的长:"); 53 int length = sc.nextInt(); 54 System.out.println("请输入长方形的宽:"); 55 int width = sc.nextInt(); 56 57 //创建长方形对象 58 ChangFangXing cfx = new ChangFangXing(); 59 //先给成员变量赋值 60 cfx.setLength(length); 61 cfx.setWidth(width); 62 63 System.out.println("周长是:"+cfx.getZhouChang()); 64 System.out.println("面积是:"+cfx.getArea()); 65 } 66 } --------------------------------------- (4)员工案例。 定义一个员工类,自己分析出几个成员变量来, 然后给出成员变量,构造方法,getXxx()/setXxx()方法, 以及一个显示所有成员信息的show()方法。并测试。 (5)MyMath案例(自己提供加减乘除并测试)。 没有成员变量和构造方法,只有成员方法。----------------------------------------------------------------------------- 10:static关键字(理解) (0) 针对多个对象有共同的成员变量的时候, Java就提供了一个关键字来修饰:static。 (1)静态的意思,可以修饰成员变量和成员方法。 (2)静态的特点: A:随着类的加载而加载。(回想main方法) B:优先于对象存在。 C:被类的所有对象共享。 这其实也是我们判断该不该使用静态的依据。 举例:饮水机和水杯的问题思考。(成员变量饮水机就用静态来修饰) D:可以通过类名调用。 既可以通过对象名调用,也可以通过类名调用。 建议通过类名调用。 (因为静态修饰的内容一般我们称之为:类成员,与类相关的。) (不是静态修饰的内容一般我们称之为:对象成员,与对象相关的。)示例代码如下: 1 class Student { 2 //非静态的成员变量 3 int num = 10; 4 5 //静态的成员变量 6 static int num2 = 20; 7 } 8 9 class StudentDemo { 10 public static void main(String[] args) { 11 Student s = new Student(); 12 System.out.println(s.num); 13 14 //通过类名调用 15 System.out.println(Student.num2); 16 //通过对象名调用 17 System.out.println(s.num2); 18 } 19 } ----------------------------------------------------------------------------- (3)静态的内存图 静态的内容在方法区的静态区。 如下图所示06: ----------------------------------------------------------------------------- (4)静态的注意事项: A:在静态方法中没有this对象。 如何理解呢? 答:因为静态是随着类的加载而加载,而this随着对象的创建而存在。 即静态比对象先存在。 B:静态方法只能访问静态的成员变量和静态的成员方法。 如下图所示07: ----------------------------------------------------------------------------- (5)静态变量和成员变量的区别: A:所属不同 静态变量:属于类,也称为类变量。 成员变量:属于对象,也称为对象变量或实例变量。 B:在内存中的位置不同 静态变量:存储于方法区的静态区。 成员变量:存储于堆内存。 C:生命周期不同 静态变量:静态变量是随着类的加载而加载,随着类的消失而消失。 成员变量:成员变量是随着对象的创建而存在,随着对象的消失而消失。 D:调用不同 静态变量:可以通过对象名调用,也可以通过类名调用。 成员变量:只能通过对象名调用。----------------------------------------------------------------------------- (6)main方法是静态的解释 public static void main(String[] args) {...} public:公共的,访问权限是最大,由于main方法是被jvm调用的,所以权限要够大。 static:静态的,不需要创建对象。通过类名就可以调用,方便jvm的调用。 void:方法的返回值是返回给调用者的,而main方法是被jvm调用的,返回值给jvm没有意义。 main:就是一个常见的名称,是一个常见的程序入口。 String[] args:是一个字符串数组,早期用于接收键盘录入数据,提供程序的灵活性。 格式:java MainDemo hello world java 如下图所示08: =============================================================================我的GitHub地址: https://github.com/heizemingjun 我的博客园地址: http://www.cnblogs.com/chenmingjun 我的蚂蚁笔记博客地址: http://blog.leanote.com/chenmingjun Copyright ©2018 黑泽明军 【转载文章务必保留出处和署名,谢谢!】

优秀的个人博客,低调大师

java基础学习_面向对象(上)01_day07总结

==========================================================================================================================================================涉及到的知识点有:1:面向对象(掌握) (0)面向过程和面向过程开发 (1)面向对象思想概述 (2)面向对象的思想特点 (3)把大象装进冰箱(理解) (4)类与对象的关系 (5)类的定义及使用 (6)案例 (7)内存图 (8)Java程序的开发、设计和特征==========================================================================================================================================================1:面向对象(掌握) (0)面向过程和面向过程开发 面向过程:每一个具体步骤中我们都是参与者(执行者),并且需要面对具体的每一个步骤和过程。 面向过程开发:其实就是面向着具体的每一个步骤和过程,把每一个步骤和过程完成,然后由这些功能方法相互调用,完成需求。 (1)面向对象思想概述 面向对象是基于面向过程的编程思想。 (2)面向对象的思想特点: A:是一种更符合我们思考习惯的思想。 B:把复杂的事情简单化。 C:让我们从执行者(参与者)变成了指挥者。(角色发生了转换) 举例: 买电脑: 面向过程:我先了解电脑-->了解我自己的需求:学习用-->找对应的参数信息-->去中关村买电脑-->讨价还价-->买回电脑。 面向对象:我知道我要买电脑-->班长去给我买-->班长就买回来了。 洗衣服: 面向过程:把衣服脱下-->找一个盆-->放点洗衣粉-->加点水-->把衣服扔进去-->搓一搓-->清洗衣服-->拧干-->晾起来。 面向对象:把衣服脱下-->打开全自动洗衣机-->扔进去-->一键即可-->晾起来。 吃饭: 面向过程:去超市买菜-->摘菜-->洗菜-->切菜-->炒菜-->盛起来-->吃。 面向对象:去饭店-->服务员(点菜)-->厨师(做菜)-->服务员(端菜)--吃。 万事万物皆对象! 家常事物、买洗衣机和去饭店太不划算了,所以,找个对象。 (3)把大象装进冰箱(理解) A:面向过程实现 B:面向对象实现 注意:如何让我们的操作更符合面向对象思想呢? A:有哪些类呢? B:每个类有哪些东西呢? C:类与类之间的关系是什么呢? (4)类与对象的关系: 我们学习编程语言,是为了模拟现实世界的事物的。 A:现实世界的事物,我们如何表示呢? 属性 该事物的基本描述信息 行为 该事物的功能(该事物能够做什么) B:Java语言中最基本的单位是类。所以,我们就应该把事物用一个类来体现 C:类 成员变量 ==> 事物属性 成员方法 ==> 事物行为 D: 类:是一组相关的属性和行为的集合。是一个抽象的概念。 对象:是该类事物的具体体现(存在),是一个具体的实例。(对象) 类:可以理解为构造对象的一个蓝图或者模版,是抽象的概念。 对象:是以类为模型创建的具体实例,是对类的一种具体化。 举例: 类 --> 学生(抽象的) 对象 --> 班长就是一个对象(具体的) 如下图所示01: (5)类的定义及使用: A:类的定义:定义一个类其实就是定义该类的成员(成员变量和成员方法) 成员变量 定义格式和以前一样,就是位置不同,在类中,方法外。 成员方法 定义格式和以前一样,就是去掉了static。 B:如何使用类的内容? 在一个java文件中写两个类:一个基本的类,一个测试类。 注意:文件的名称和测试类的名称一致。 a:创建对象使用。格式如下: 类名 对象名 = new 类名(); b:如何使用成员变量和成员方法呢? 对象名.成员变量 对象名.成员方法() (6)案例: A:学生类的定义和使用 B:手机类的定义和使用 (7)内存图: A:一个对象的内存图 B:二个对象的内存图 C:三个对象的内存图 如下图所示02: (8)Java程序的开发、设计和特征 A:开发:就是不断的创建对象,通过对象调用功能。 B:设计:就是管理和维护对象间的关系。 C:特征 a:封装 b:继承 c:多态=============================================================================我的GitHub地址: https://github.com/heizemingjun 我的博客园地址: http://www.cnblogs.com/chenmingjun 我的蚂蚁笔记博客地址: http://blog.leanote.com/chenmingjun Copyright ©2018 黑泽明军 【转载文章务必保留出处和署名,谢谢!】

优秀的个人博客,低调大师

java基础学习_基础语法(下)02_day06总结

========================================================================================================================================================== 涉及到的知识点有:1:二维数组(理解) (1)二维数组的定义 (2)二维数组的格式 格式一:(自动动态初始化) 格式二:(半自动动态初始化) 格式三:(静态初始化) 面试题: (3)二维数组的案例(掌握) A:二维数组的遍历 B:二维数组的求和 C:打印杨辉三角形(行数可以键盘录入)2:两个思考题(理解) (1)Java中的参数传递问题及图解。 (2)数据加密问题。 ==========================================================================================================================================================1:二维数组(理解) (1)二维数组的定义:元素是一维数组的数组。 (2)二维数组的格式: 格式一:(自动动态初始化) 数据类型[][] 数组名 = new 数据类型[m][n]; //常用这个格式。 数据类型 数组名[][] = new 数据类型[m][n]; //该格式可以,但是很少用了。 数据类型[] 数组名[] = new 数据类型[m][n]; //该格式也可以,但是很少用了。 m表示这个二维数组有多少个一维数组。 n表示每一个一维数组的元素个数。 举例: int[][] arr = new int[3][2]; 定义了一个二维数组arr。 这个二维数组有3个一维数组,名称是arr[0],arr[1],arr[2]。 每个一维数组有2个元素,可以通过arr[m][n]来获取。 即: arr[m][n] 表示获取第m+1个一维数组的第n+1个元素。 例如:arr[1][2] 表示获取第2个一维数组的第3个元素。 如下如图所示01: --------------------------------------- 格式二:(半自动动态初始化) 数据类型[][] 数组名 = new 数据类型[m][]; m表示这个二维数组有多少个一维数组。 这一次没有直接给出一维数组的元素个数,可以动态的给出。 举例: int[][] arr = new int[3][]; arr[0] = new int[2]; arr[1] = new int[3]; arr[2] = new int[1]; 如下如图所示02: --------------------------------------- 格式三:(静态初始化) 数据类型[][] 数组名 = new 数据类型[][]{ {...}, {...}, {...} }; 数据类型[][] 数组名 = { {...}, {...}, {...} }; 格式三的简化版格式 举例: int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } }; int[][] arr = { { 1, 2, 3 }, { 4, 5 }, { 6 } }; 如下如图所示03: 面试题: 下面定义的区别: int x, y; //定义了1个int类型的变量x,同时也定义了1个int类型的变量y。 //等价于 int x; int y; --------------------------------------- int[] x, y[]; //定义了1个int类型的一维数组x,同时也定义了1个int类型的二维数组y。 //等价于 int[] x; int[] y[]; (3)二维数组的案例(掌握): A:二维数组的遍历 外循环控制的是二维数组的长度,其实就是一维数组的个数。 内循环控制的是一维数组的长度。 public static void printArray2(int[][] arr) { for(int x = 0; x < arr.length; x++) { for(int y = 0; y < arr[x].length; y++) { System.out.print(arr[x][y]+" "); } System.out.println(); } } B:二维数组的求和 int sum = 0; for(int x = 0; x < arr.length; x++) { for(int y = 0; y < arr[x].length; y++) { sum += arr[x][y]; } } C:打印杨辉三角形(行数可以键盘录入) 1 /* 2 需求:打印杨辉三角形(行数可以键盘录入) 3 4 1 5 1 1 6 1 2 1 7 1 3 3 1 8 1 4 6 4 1 9 1 5 10 10 5 1 10 11 分析:看这种图像的规律: 12 A:任何一行的第一列和最后一列都是1。 13 B:从第三行开始,除去第一列和最后一列,剩余的每一列的数据是它上一行的前一列和它上一行的本列之和。 14 15 步骤: 16 A:首先定义一个二维数组。行数如果是n,我们把列数也先定义为n。 17 这个n的数据来自于键盘录入。 18 B:给这个二维数组任何一行的第一列和最后一列赋值为1。 19 C:按照规律给其他元素赋值: 20 从第三行开始,除去第一列和最后一列,剩余的每一列的数据是它上一行的前一列和它上一行的本列之和。 21 D:遍历这个二维数组。 22 */ 23 import java.util.Scanner; 24 25 class Array2Test3 { 26 public static void main(String[] args) { 27 //创建键盘录入对象。 28 Scanner sc = new Scanner(System.in); 29 30 //这个n的数据来自于键盘录入。 31 System.out.println("请输入一个数据:"); 32 int n = sc.nextInt(); 33 34 //定义二维数组 35 int[][] arr = new int[n][n]; 36 37 //给这个二维数组任何一行的第一列和最后一列赋值为1 38 for(int x = 0; x < arr.length; x++) { 39 arr[x][0] = 1; //任何一行第一列 40 arr[x][x] = 1; //任何一行的最后一列 41 } 42 43 //按照规律给其他元素赋值 44 //从第三行开始,除去第一列和最后一列,剩余的每一列的数据是它上一行的前一列和它上一行的本列之和。 45 for(int x = 2; x < arr.length; x++) { 46 //这里如果 y <= x 是有个小问题的,就是最后一列的问题,因为最后一列已经给过值了。 47 //所以这里要减去1 48 //并且y也应该从1开始,因为第一列也给过值了。 49 for(int y = 1; y <= x - 1; y++) { 50 //除去第一列和最后一列,剩余的每一列的数据是它上一行的前一列和它上一行的本列之和。 51 arr[x][y] = arr[x - 1][y - 1] + arr[x - 1][y]; 52 } 53 } 54 55 //遍历这个二维数组。 56 /* 57 for(int x = 0; x < arr.length; x++) { 58 for(int y = 0; y < arr[x].length; y++) { 59 System.out.print(arr[x][y]+"\t"); 60 } 61 System.out.println(); 62 } 63 */ 64 //这个时候,要注意了,内循环的变化必须和曾经讲过的九九乘法表类似。 65 for(int x = 0; x < arr.length; x++) { 66 for(int y = 0; y <= x; y++) { 67 System.out.print(arr[x][y]+"\t"); 68 } 69 System.out.println(); 70 } 71 } 72 } -----------------------------------------------------------------------------2:两个思考题(理解) (1)Java中的参数传递问题及图解。 基本类型:形式参数的改变对实际参数没有影响。 引用类型:形式参数的改变直接影响实际参数。 基本类型:传递的是基本类型的数据值。 引用类型:传递的是地址值。 小结:不管怎么说,都是值,即在Java中,只有值传递。 如下图所示04: (2)数据加密问题。 综合的小案例。 int index = 0; arr[index] = number % 10 = number / 1 % 10; index++; arr[index] = number / 10 % 10 = number / 10 % 10; index++; arr[index] = number / 10 / 10 % 10 = number /100 % 10; ...... --------------------------------------- int index = 0; while (number > 0) { arr[index] = number % 10; number /= 10; } 示例代码如下: 1 /* 2 把刚才的代码改进一下: 3 A:把数据改进为键盘录入 4 B:把代码改进为方法实现 5 6 7 另一个数据的测试: 8 number:1234567 9 第一步:7654321 10 第二步:2109876 11 第三步:6109872 12 13 知识点: 14 变量 15 数据类型 16 运算符 17 键盘录入 18 语句 19 方法 20 数组 21 */ 22 import java.util.Scanner; 23 24 class JiaMiDemo2 { 25 public static void main(String[] args) { 26 //创建键盘录入对象 27 Scanner sc = new Scanner(System.in); 28 29 //请输入一个数据 30 System.out.println("请输入一个数据(小于8位):"); 31 int number = sc.nextInt(); 32 33 //写功能实现把number进行加密 34 //调用 35 String result = jiaMi(number); 36 System.out.println("加密后的结果是:"+result); 37 } 38 39 /* 40 需求:写一个功能,把数据number实现加密。 41 两个明确: 42 返回值类型:String 为了做一个字符串的拼接。 43 参数列表:int number 44 */ 45 public static String jiaMi(int number) { 46 //定义数组 47 int[] arr = new int[8]; 48 49 //定义索引 50 int index = 0; 51 52 //把number中的数据想办法放到数组中 53 while(number > 0) { 54 arr[index] = number % 10; 55 index++; 56 number /= 10; 57 } 58 59 //把每个数据加5,然后对10取得余数 60 for(int x = 0; x < index; x++) { 61 arr[x] += 5; 62 arr[x] %= 10; 63 } 64 65 //把第一位和最后一位交换 66 int temp = arr[0]; 67 arr[0] = arr[index - 1]; 68 arr[index - 1] = temp; 69 70 //把数组的元素拼接成一个字符串返回 71 //定义一个空内容字符串 72 String s = ""; 73 74 for(int x = 0; x < index; x++) { 75 s += arr[x]; 76 } 77 78 return s; 79 } 80 } =============================================================================我的GitHub地址: https://github.com/heizemingjun 我的博客园地址: http://www.cnblogs.com/chenmingjun 我的蚂蚁笔记博客地址: http://blog.leanote.com/chenmingjun Copyright ©2018 黑泽明军 【转载文章务必保留出处和署名,谢谢!】

资源下载

更多资源
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长,特征是大鼻子、头戴帽子、身穿背带裤,还留着胡子。与他的双胞胎兄弟路易基一起,长年担任任天堂的招牌角色。

腾讯云软件源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题,腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构,目前腾讯云软件源站支持公网访问和内网访问。

Nacos

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称,一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集,帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring

Spring框架(Spring Framework)是由Rod Johnson于2002年提出的开源Java企业级应用框架,旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念,提供核心容器、应用上下文、数据访问集成等模块,支持整合Hibernate、Struts等第三方框架,其适用范围不仅限于服务器端开发,绝大多数Java应用均可从中受益。

用户登录
用户注册
修改密码
忘记密码