首页 文章 精选 留言 我的

精选列表

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

Day2&Day3@JavaOne2017

1. Java Keynotes 先是社区代表亮相,为Java社区背书。 接下来是每年都有的Innovation Sponsor Intel的时间,当然不全是广告,从这个过程中还是可以了解到Intel的一些策略和核心关注点。 Data is Future They want to enable the Future by Speed, Scale and Smart They have proof that they are faster enough! And us Alibaba represents Scalable, Proud! Smart means supporting AI这里面提出了OpenJDK的Panama项目的Vector API,用于支持AI,详情前往https://software.intel.com/en-us/articles/vector-api-developer-program-for-java 接下来的部分主要是介绍Java与Cloud,微服务的紧密关系。以及JAVA9的部分特性。包含一系列的DEMO演示,这里就不多说了,相信其它同学会有更详细的介绍这块内容。我个人的收获就是我极大的增强了对JAVA的信心,我不需要学习其它编程语言了,哈哈 2. Micro Services related at this JavaOne 2.1 异步编排微服务 此次的微服务相关主题绝大部分都与异步、Reactive、Message Driven、Event Sourcing有关,其实这与很多年前ebay所提出来的能异步则异步很相似。 简单来说就是异步化、消息驱动的微服务编排架构。这样做的好处是什么呢? 松耦合 更少的对设计者的依赖,很好的契合了微服务所提倡的自治 更好的并发以及更好的容错性 当然,不完全是好处,也有缺点:执行的不可预测性,以及不可测性。我觉得作者有意没有讲出更多的缺点。很多相关的Speaker都提出来Reactive的系统,比如用户提交时异步变更数据库,通过异步的Server Push再告知用户结果,有一些为了用而用的嫌疑,因为这样会带来很多复杂性,也会对用户体验有影响。Anyway, 我们应该审视一下我们哪些系统或服务或模块是可以异步的 2.2 我收获最多的微服务session 一、微服务绝对不仅仅是小,是单一职责的原则就可以了,微服务要实现团队间依赖更少的合作,服务要实现自治(做神一样的队友) 二、承诺说,有点像我们文化里面的ownership,"即使不是自己的职责,也是推诿"。大家仔细体会一下,尤其是那个tweet。 三、越Hot的数据往往占用了越多的资源,对性能也越关键,但往往是占用更少的空间。但是 往往有很多多的不同解决方案 四、没有所谓的无状态, 只是将状态推脱给别人。现实生活中,我们的很多方案都是不完美的,都是一种平衡,而我们往往听到一种观点,就不假思索的认为可以解决所有的问题,最后再返工浪费时间 五、所有的事实都在LOG中,数据库中的数据是LOG的子集。这个观点是用来引出Event Sourcing的,这块前面已经介绍过,这里不再详述 六、大家都讨厌最终一致,但它是necessary的

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

Hadoop The First Day!!!

Hadoop :内部工作机制非常复杂,是一个集分布式系统理论、实际工程理论和常识于一体的系统。提供用于构建分布式系统的每一个工具(用于数据存储、数据分析和协调处理)都非常简单。这些工具都非常抽象,对偶尔有大量数据需要存储的程序员、有大量数据需要分析的额程序员、有大量计算机需要管理的程序员等时期利用Hadoop构建基础平台,满足需要。 我特么才发现,需要点java基础,如果要看Hadoop的话。学前篇:2006年数字世界(digital universe)项目统计的出全球数据总量为0.18ZB并预测在2011年将达到1.8ZB。 小姿势:1ZB=10^21字节=1000EB(exabytes) 1 000 000 PB = 10亿TB(terrabytes) 数据来源可能为2007年纽约证交所曾有段时间统计数据:一天交易数据多达1TBFaceBook 存储的照片至少100亿张,存储容量约为1PBAncestry.com存储的数据约为2.5PB互联网档案馆(The Internet Archive)存储的数据量约为2PB,并以每月至少20TB的速度持续增长瑞士日内瓦附近的大型强子对撞机每年产生的数据约为15PBMyLifeBits:微软研究院的一个研究项目,研究显示,在不久的将来,个人信息档案将日益普及。MyLifeBits的一个实验是获取和保存每个人的对外联系情况,供日后存取。收集的数据包括每分钟拍摄的照片等,数据量每月约为1GB。当存储成本急剧下降以至于可以存储音频和视频时,MyLifeBits项目在未来的存储的数据量将是现在的很多倍。生活中我们一般遇到的问题:在硬盘存储容量多年来不断提升的同时,访问速度(硬盘数据读取速度)却没有与时俱进。1990年,一个普通硬盘可以存储1370MB数据,传输速度为4.4MB/s,因此只需要5分钟就可以读完整个硬盘中的数据,20年过去了,1TB的硬盘已然成为主流,但其数据传输速度约为100MB/s,读完整个硬盘中的数据至少得话2.5小时。现实中我们产生的数据量成几何倍数增长,但是对数据的处理速度却受到硬件设备很大的限制和影响,很难提升。对硬盘中的数据并行进行读写数据,有许多问题:第一个需要解决硬件故障问题;第二个是大多数分析任务需要以某种凡是结合大部分数据来共同完成分析,即从一个硬盘读取的数据可能需要与从另外99个硬盘中读取的数据结合使用。读到这里恍然发现:Hadoop即为我们常说的分布式存储系统的一种。 MapReduce看似采用了一种蛮力方法。每个查询选哟处理整个数据集成或至少数据集的绝大部分。有区别与传统的关系型数据库。即MapReduc为数据库的一种。(暂时理解)和关系型数据库进行比较:类型 传统关系型数据库 MapReduce数据大小 GB PB数据存取 交互式和批处理 批处理更新 多次读写 一次写入,多次读取结构 静态模式 动态模式完整性 高 低横向扩展 非线性的 线性的 MapReduce和关系型数据库之间的另一个区别在于它们所操作的数据集的结构化程度。结构化数据(structured data)是具有既定格式的实体化数据,如xml文档或满足特定预定一个是的数据库表等。半结构化数据(semi-structured data)比较松散,虽然可能有格式,但经常被忽略,所以它只能作为对数据结构的一般性指导。非结构化数据(unstructured data)没有什么特别的内部结构,例如纯文本或图像数据。MapReduce对非结构化或半结构化数据非常有效,因为它是在处理数据是才对数据进行解释。换句话说,MapReduce输入的键和值并不是数据固有的属性,而是有分析数据的人来选的。关系型数据库往往是规范的,以保持数据的完整性且不含冗余。规范给MapReduce带来问题,因为它使记录读取成为非本地操作。而MapReduce的核心假设之一就是可以进行(高速的)流读写操作。web服务器日志是典型的非规范化数据记录,MapReduce非常适用于分析各种日志文件MapReduce是一种线性的可伸缩编程模型。程序员需要写两个函数,分别为map函数和reduce函数,每个函数定义从一个键值对集合到另一个键值对集合的映射。这些函数不必关注数据集及其所用集群的大小,可以原封不动地应用于小规模数据集或大规模的数据集。更重要的是,如果输入的数据量是原来的两倍,那么运行时间页需要两倍。但如果集群是原来的两倍,作业的运行速度却仍然与原来一样。next:1.3.2 来源:Hadoop权威指南

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

REACT day 1

https://facebook.github.io/react/ A JAVASCRIPT LIBRARY FOR BUILDING USER INTERFACES Declarative views make your code more predictable and easier to debug. React是Facebook在2013年发布的一个前端框架,而如今的React俨然已经演变成一个前端生态,这个生态圈包含了众多基于React的框架:ReactJS、ReactCanvas、ReactNativeforiOS、ReactNativeforAndroid。由于Facebook的大力支持和众多开发者的追捧,React在前端框架中备受青睐。 react vs react native ReactJS is a JavaScript library, supporting both front end web and being run on the server, for building user interfaces and web applications. React Native is a mobile framework that compiles to native app components, allowing you to build native mobile applications (iOS, Android, and Windows) in JavaScript that allows you to use ReactJS to build your components, and implements ReactJS under the hood. Both are open sourced by Facebook. 系列教程 https://hulufei.gitbooks.io/react-tutorial/content/introduction.html

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

Day04-SmartImageView

Android SDK中自带的ImageView控件,没有根据网络的URL地址得到图片的功能。所以就得引进一个 开源控件SmartImageView,这个控件的包可以去GitHub网站上下载。 SmarImageView的能干什么 在这个开源项目中的README文件中,是这么描述这个组件的: SmartImageView是用来替换Android中标准的ImageView组件的,它新增的可能可以从URL、用户的联系地址簿获取,而且图片缓存到内存和磁盘可以更快的加载。 SmarImageView的使用 1.导包: 2.在XML中使用,注意要加上包名: 包名一般不手写,容易出错而且慢,可以找到SmartImageView.java,点击展开,右击 (C)SmartImageView,然后点击Copy Qualified Name即可复制完整的带包名的控件名。 3.在代码中使用SmartImageView 注意声明要用SmartImageView,然后调用它的setImageUrl(String url)即可得到网络图片。 img.setImageUrl(news_item.image, R.drawable.loaderror);//第1个参数表示要访 问的网络图片URL地址,第2个参数为找不到网络图片时默认显示的图片。 SmarImageView的原理 SmartImageView继承了ImageView,添加了许多新的功能,如setImageUrl,它也有很多的重载 形式。它的底层还是使用网络访问HttpURLConnection获取网络图片的,当然它也解决了缓存的问题, 还有显示图片加载进度条等功能。 总之,这些功能听起来都特别的爽,不过在用开源项目的同时,最好先要大概理解一下它的原理 本文转自屠夫章哥 51CTO博客,原文链接:http://blog.51cto.com/4259297/1676062,如需转载请自行联系原作者

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

workbuddy使用day2

### **今日完成任务领取积分。** ### **新手任务:领取一只 Buddy ** #### **任务要求** 新建 1 个任务并发起对话,完成后奖励 300Credits+8 能量,解锁「命中注定」徽章。 #### **操作步骤** 1. 下载安装 WorkBuddy 客户端,使用和网页端一致的微信 / 手机号登录; 1. 客户端左上角点击「+ 新建任务」,任意选择办公 / 代码 / 设计创意模式; 1. 输入任意一句话发送对话,例如:帮我写一段简单 JS 代码; 1. 对话生成完成后,回到网页成长计划页面,任务自动标记完成,领取奖励。 ### **探索优秀灵感** 1. 客户端首页点击【更多】→进入【灵感】案例库; 1. 任选任意案例,点击「+ 做同款」,发送对话生成内容即完成。 #### **4召唤专业高考顾问 ** 1. 客户端顶部【专家】分类; 1. 找到「高考我帮你」专家,召唤后发送任意高考相关提问,对话生成即达标。 #### **和 AI 聊天 5 次** 任意模式输入框发送文字 / 图片 / 语音,累计 5 次独立对话即可,无内容限制。

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

JAVA学习day13

1、finalfinal的意思为最终,不可变。final是个修饰符,它可以用来修饰类,类的成员,以及局部变量。 2、final的特点l final修饰类不可以被继承,但是可以继承其他类。class Yy {}final class Fu extends Yy{} //可以继承Yy类class Zi extends Fu{} //不能继承Fu类l final修饰的方法不可以被覆盖,但父类中没有被final修饰方法,子类覆盖后可以加final。class Fu { // final修饰的方法,不可以被覆盖,但可以继承使用 public final void method1(){} public void method2(){} }class Zi extends Fu { //重写method2方法 public final void method2(){} }l final修饰的变量称为常量,这些变量只能赋值一次。final int i = 20;i = 30; //赋值报错,final修饰的变量只能赋值一次l 引用类型的变量值为对象地址值,地址值不能更改,但是地址内的对象属性值可以修改。final Person p = new Person();Person p2 = new Person();p = p2; //final修饰的变量p,所记录的地址值不能改变p.name = "小明";//可以更改p对象中name属性值p不能为别的对象,而p对象中的name或age属性值可更改。l 修饰成员变量,需要在创建对象前赋值,否则报错。(当没有显式赋值时,多个构造方法的均需要为其赋值。)class Demo { //直接赋值 final int m = 100; //final修饰的成员变量,需要在创建对象前赋值,否则报错。 final int n; public Demo(){ //可以在创建对象时所调用的构造方法中,为变量n赋值 n = 2016; } } 3、static关键字3-1、static特点l 被static修饰的成员变量属于类,不属于这个类的某个对象。(也就是说,多个对象在访问或修改static修饰的成员变量时,其中一个对象将static成员变量值进行了修改,其他对象中的static成员变量值跟着改变,即多个对象共享同一个static成员变量)代码演示:class Demo { public static int num = 100; }class Test { public static void main(String[] args) { Demo d1 = new Demo(); Demo d2 = new Demo(); d1.num = 200; System.out.println(d1.num); //结果为200 System.out.println(d2.num); //结果为200 } }l 被static修饰的成员可以并且建议通过类名直接访问。访问静态成员的格式:类名.静态成员变量名类名.静态成员方法名(参数)对象名.静态成员变量名 ------不建议使用该方式,会出现警告对象名.静态成员方法名(参数) ------不建议使用该方式,会出现警告代码演示:class Demo { //静态成员变量 public static int num = 100; //静态方法 public static void method(){ System.out.println("静态方法"); } }class Test { public static void main(String[] args) { System.out.println(Demo.num); Demo.method(); } } 3-2、static注意事项l 静态内容是优先于对象存在,只能访问静态,不能使用this/super。静态修饰的内容存于静态区。class Demo { //成员变量 public int num = 100; //静态方法 public static void method(){ //this.num; 不能使用this/super。 System.out.println(this.num); } }l 同一个类中,静态成员只能访问静态成员class Demo { //成员变量 public int num = 100; //静态成员变量 public static int count = 200; //静态方法 public static void method(){ //System.out.println(num); 静态方法中,只能访问静态成员变量或静态成员方法 System.out.println(count); } }l main方法为静态方法仅仅为程序执行入口,它不属于任何一个对象,可以定义在任意类中。 4、定义静态常量开发中,我们想在类中定义一个静态常量,通常使用public static final修饰的变量来完成定义。此时变量名用全部大写,多个单词使用下划线连接。定义格式:public static final 数据类型 变量名 = 值;如下演示:class Company { public static final String COMPANY_NAME = "传智播客"; public static void method(){ System.out.println("一个静态方法"); } }当我们想使用类的静态成员时,不需要创建对象,直接使用类名来访问即可。System.out.println(Company.COMPANY_NAME); //打印传智播客Company.method(); // 调用一个静态方法l 注意:接口中的每个成员变量都默认使用public static final修饰。所有接口中的成员变量已是静态常量,由于接口没有构造方法,所以必须显示赋值。可以直接用接口名访问。interface Inter { public static final int COUNT = 100; }访问接口中的静态变量Inter.COUNT 5、匿名对象的概念匿名对象是指创建对象时,只有创建对象的语句,却没有把对象地址值赋值给某个变量。如:已经存在的类:public class Person{ public void eat(){ System.out.println(); }}创建一个普通对象Person p = new Person();创建一个匿名对象new Person(); 6、匿名对象的特点l 创建匿名对象直接使用,没有变量名。new Person().eat() //eat方法被一个没有名字的Person对象调用了。l 匿名对象在没有指定其引用变量时,只能使用一次。new Person().eat(); 创建一个匿名对象,调用eat方法new Person().eat(); 想再次调用eat方法,重新创建了一个匿名对象l 匿名对象可以作为方法接收的参数、方法返回值使用class Demo { public static Person getPerson(){ //普通方式 //Person p = new Person(); //return p; //匿名对象作为方法返回值 return new Person(); } public static void method(Person p){} }class Test { public static void main(String[] args) { //调用getPerson方法,得到一个Person对象 Person person = Demo.getPerson(); //调用method方法 Demo.method(person); //匿名对象作为方法接收的参数 Demo.method(new Person()); } } 7、内部类在内部类中可以直接访问外部类的所有成员; 7-1、成员内部类成员内部类,定义在外部类中的成员位置。与类中的成员变量相似,可通过外部类对象进行访问l 定义格式class 外部类 { 修饰符 class 内部类 { //其他代码 }}l 访问方式外部类名.内部类名 变量名 = new 外部类名().new 内部类名();l 成员内部类代码演示定义类class Body {//外部类,身体 private boolean life= true; //生命状态 public class Heart { //内部类,心脏 public void jump() { System.out.println("心脏噗通噗通的跳") System.out.println("生命状态" + life); //访问外部类成员变量 } }}访问内部类public static void main(String[] args) { //创建内部类对象 Body.Heart bh = new Body().new Heart(); //调用内部类中的方法 bh.jump(); } 7-2、局部内部类局部内部类,定义在外部类方法中的局部位置。与访问方法中的局部变量相似,可通过调用方法进行访问l 定义格式class 外部类 { 修饰符 返回值类型 方法名(参数) { class 内部类 { //其他代码 } }}l 访问方式在外部类方法中,创建内部类对象,进行访问l 局部内部类代码演示定义类class Party {//外部类,聚会 public void puffBall(){// 吹气球方法 class Ball {// 内部类,气球 public void puff(){ System.out.println("气球膨胀了"); } } //创建内部类对象,调用puff方法 new Ball().puff(); }}访问内部类public static void main(String[] args) { //创建外部类对象 Party p = new Party(); //调用外部类中的puffBall方法 p.puffBall(); } 8、包通常使用公司网址反写,可以有多层包,包名采用全部小写字母,多层包之间用”.”连接类中包的声明格式: package 包名.包名.包名…;如:黑马程序员网址itheima.com那么网址反写就为com.itheima 传智播客 itcast.cn 那么网址反写就为 cn.itcast l 注意:声明包的语句,必须写在程序有效代码的第一行(注释不算)l 代码演示:package cn.itcast; //包的声明,必须在有效代码的第一行import java.util.Scanner;import java.util.Random;public class Demo {} l import导包代码书写的位置:在声明包package后,定义所有类class前,使用导包import包名.包名.类名; 9、访问修饰符在Java中提供了四种访问权限,使用不同的访问权限时,被修饰的内容会有不同的访问权限,以下表来说明不同权限的访问能力: public protected default private同一类中 √ √ √ √同一包中(子类与无关类) √ √ √ 不同包的子类 √ √ 不同包中的无关类 √ 归纳一下:在日常开发过程中,编写的类、方法、成员变量的访问l 要想仅能在本类中访问使用private修饰;l 要想本包中的类都可以访问不加修饰符即可;l 要想本包中的类与其他包中的子类可以访问使用protected修饰l 要想所有包中的所有类都可以访问使用public修饰。l 注意:如果类用public修饰,则类名必须与文件名相同。一个文件中只能有一个public修饰的类。 10、知识点总结l final:关键字,最终的意思 final修饰的类:最终的类,不能被继承 final修饰的变量: 相当于是一个常量, 在编译生产.class文件后,该变量变为常量值 final修饰的方法: 最终的方法,子类不能重写,可以继承过来使用 l static : 关键字, 静态的意思 可以用来修饰类中的成员(成员变量,成员方法) 注意: 也可以用来修饰成员内部类 n 特点: 被静态所修饰的成员,会被所有的对象所共享 被静态所修饰的成员,可以通过类名直接调用,方便 Person.country = "中国"; Person.method(); n 注意事项: 静态的成员,随着类的加载而加载,优先于对象存在 在静态方法中,没有this关键字 静态方法中,只能调用静态的成员(静态成员变量,静态成员方法 l 匿名对象:一个没有名字的对象 n 特点: 创建匿名对象直接使用,没有变量名 匿名对象在没有指定其引用变量时,只能使用一次 匿名对象可以作为方法接收的参数、方法返回值使用 l 内部类:在一个类中,定义了一个新类,这个新的类就是内部类 class A {//外部类 class B{// 内部类 } } n 特点: 内部类可以直接访问外部类的成员,包含私有的成员 l 包的声明与访问 n 类中包的声明格式: package 包名.包名.包名…; n 带有包的类,创建对象格式:包名.类名 变量名 = new包名.类名(); cn.itcast.Demo d = new cn.itcast.Demo(); n 导包的格式: import 包名.类名; l 权限修饰符 public : 公共的 protected: 受保护的 private : 私有的 public protected 默认的 private 在当前类中 Y Y Y Y 同一包中的其他类 Y Y Y 不同包中的子类 Y Y 不同包中的其他类 Y l 代码块: 局部代码块:定义在方法中的,用来限制变量的作用范围 构造代码块:定义在类中方法外,用来给对象中的成员初始化赋值 静态代码块:定义在类中方法外,用来给类的静态成员初始化赋值

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

JAVA学习day12

1、构造方法在创建对象的时候,就有属性值——构造方法 set和get方法时对象创建后使用的 2、什么时候需要写构造方法2-1)当描述的事物在创建其对象时就要明确属性的值,这时就需要在定义类的时候书写带参数的构造方法。2-2)若创建对象时不需要明确具体的数据,这时可以不用书写构造方法(不书写也有默认的构造方法)。 没有写构造方法的:在编译时系统会自动创建一个空的构造方法class Person { //如果没有显示指定构造方法,编译会在编译时自动添加默认的构造方法 //Person(){} //空参数的默认构造方法 } 3、构造方法的格式:修饰符 构造方法名(参数列表){} 4、构造方法的体现: 构造方法没有返回值类型。也不需要写返回值。因为它是为构建对象的,对象创建完,方法就执行结束。 构造方法名称必须和类型保持一致。 构造方法没有具体的返回值。 构造方法的代码体现:class Person { // Person的成员属性age和name private int age; private String name; // Person的构造方法,拥有参数列表 Person(int a, String nm) { // 接受到创建对象时传递进来的值,将值赋给成员属性 age = a; name = nm; } } 5、构造方法的细节:1、一个类中可以有多个构造方法,多个构造方法是以重载的形式存在的2、构造方法是可以被private修饰的,作用:其他程序无法创建该类的对象。class Person { private int age; private String name; // 私有无参数的构造方法,即外界不能通过new Person();语句创建本类对象 private Person() { } // 多个构造方法是以重载的形式存在 Person(int a) { age = a; } Person(String nm, int a) { name = nm; age = a; } } 6、this调用构造方法构造方法之间的调用,可以通过this关键字来完成。l 构造方法调用格式:this(参数列表);l 构造方法的调用class Person { // Person的成员属性 private int age; private String name; // 无参数的构造方法 Person() { } // 给姓名初始化的构造方法 Person(String nm) { name = nm; } // 给姓名和年龄初始化的构造方法 Person(String nm, int a) { // 由于已经存在给姓名进行初始化的构造方法 name = nm;因此只需要调用即可 // 调用其他构造方法,需要通过this关键字来调用 this(nm); // 给年龄初始化 age = a; } } l 注意:this到底代表什么呢?this代表的是对象,具体代表哪个对象呢?哪个对象调用了this所在的方法,this就代表哪个对象。调用其他构造方法的语句必须定义在构造方法的第一行,原因是初始化动作要最先执行。 7、子父类中构造方法的调用在创建子类对象时,父类的构造方法会先执行,因为子类中所有构造方法的第一行有默认的隐式super();语句。格式:调用本类中的构造方法this(实参列表);调用父类中的空参数构造方法super();调用父类中的有参数构造方法 super(实参列表); 为什么子类对象创建都要访问父类中的构造方法?因为子类继承了父类的内容,所以创建对象时,必须要先看父类是如何对其内容进行初始化的,看如下程序:public class Test { public static void main(String[] args) { new Zi(); } }class Fu{ int num ; Fu(){ System.out.println("Fu构造方法"+num); num = 4; } }class Zi extends Fu{ Zi(){ //super(); 调用父类空参数构造方法 System.out.println("Zi构造方法"+num); } }执行结果: Fu构造方法0 Zi构造方法4 通过结果发现,子类构造方法执行时中,调用了父类构造方法,这说明,子类构造方法中有一句super()。那么,子类中的构造方法为什么会有一句隐式的super()呢?原因:子类会继承父类中的内容,所以子类在初始化时,必须先到父类中去执行父类的初始化动作。这样,才可以使用父类中的内容。当父类中没有空参数构造方法时,子类的构造方法必须有显示的super语句,指定要访问的父类有参数构造方法。 8、知识点总结l this关键字n this关键字,本类对象的引用 u this是在方法中使用的,哪个对象调用了该方法,那么,this就代表调用该方法的对象引用 u this什么时候存在的?当创建对象的时候,this存在的 u this的作用:用来区别同名的成员变量与局部变量(this.成员变量) public void setName(String name) { this.name = name; } l 构造方法: 用来给类的成员进行初始化操作n 格式: 修饰符 类名 (参数列表) { ... } n 构造方法的特点: u 1, 方法名与类名相同 u 2,没有返回值,也没有返回值类型,连void也没有 n 构造方法什么时候会被调用执行? 只有在创建对象的时候才可以被调用 l super: 指的是父类的存储空间(理解为父类的引用)调用父类的成员变量: super.成员变量; 调用父类的构造方法: super(参数); 调用方法的成员方法: super.成员方法(); l 继承中的构造方法注意事项: 1,如果我们手动给出了构造方法,编译器不会在给我们提供默认的空参数构造方法 如果我们没写任何的构造方法,编译器提供给我们一个空参数构造方法 2, 在构造方法中,默认的第一条语句为 super(); 它是用来访问父类中的空参数构造方法,进行父类成员的初始化操作 3, 当父类中没有空参数构造方法的时候,怎么办? a: 通过 super(参数) 访问父类有参数的构造方法 b: 通过 this(参数) 访问本类中其他构造方法 注意:[本类中的其他构造方法已经能够正常访问父类构造方法] 4, super(参数) 与 this(参数) 不能同时在构造方法中存在

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

JAVA学习day11

1、接口概述接口只描述所应该具备的方法,并没有具体实现,具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离,优化了程序设计。请记住:一切事物均有功能,即一切事物均有接口。 2、接口定义接口定义时需要使用interface关键字定义格式:public interface 接口名 {抽象方法1;抽象方法2;抽象方法3;}使用interface代替了原来的class,其他步骤与定义类相同:l 接口中的方法均为公共访问public的抽象方法l 接口中无法定义普通的成员变量 3、接口中成员变量的定义要求:必须定义为常量固定格式:Public static final 数据类型 变量名 = 值; 4、类与接口的关系实现关系定义类:实现接口,重写接口中的抽象方法类实现接口,可以理解为继承 关键字 implements 称为接口的实现类Class 类 implements 接口{ 重写接口中的抽象方法 } PS:只能创建接口的实现类的对象,不能创建接口的对象 /* 定义接口 使用关键字interface 接口名字 接口定义: 成员方法,全抽象 不能定义带有方法体的方法 定义抽象方法: 固定格式 public abstract 返回值类型 方法名字(参数列表); 修饰符 public 写,或者不写,都是public 接口中成员变量的定义 成员变量的定义,具体要求 要求 : 必须定义为常量 固定格式: public static final 数据类型 变量名 = 值*/ public interface MyInterface { //public static final int a = 1; //在接口中,定义抽象的方法 public abstract void function(); } ================================================/* 定义类, 实现接口,重写接口中的抽象方法 创建实现类的对象 类实现接口, 可以理解为继承 关键字 implements class 类 implements 接口{ 重写接口中的抽象方法 } 类 实现 接口 class MyInterfaceImpl implements MyInterface*/ public class MyInterfaceImpl implements MyInterface{ public void function(){ System.out.println("实现类,重写接口抽象方法"); } } =================================================测试public class Test { public static void main(String[] args) { //创建接口的实现类的对象 MyInterfaceImpl my = new MyInterfaceImpl(); my.function(); } } 5、接口中成员变量的特点6、接口中成员方法的特点 /* 接口中成员的特点 成员变量的特点, 没有变量,都是常量 固定定义格式: public static final 数据类型 变量名 = 值 public 权限 static 可以被类名直接.调用 final 最终,固定住变量的值 // * 注意: public static final 修饰符,在接口的定义中,可以省略不写 但是,不写不等于没有 三个修饰符,还可以选择性书写 接口中的成员方法特点: public abstract 返回值类型 方法名(参数列表) 修饰符 public abstract 可以不写,选择性书写 但是,写不写,都有 实现类,实现接口,重写接口全部抽象方法,创建实现类对象 实现类必须重写所有抽象方法,才能定义类对象,否则仍然是抽象类 实现类,重写了一部分抽象方法,实现类,还是一个抽象类*/ public interface MyInter { public static final int x = 3; public abstract void show(); public abstract int getSum(int a,int b); } 7、接口和抽象类的区别: 抽象类是应该有的接口是额外功能的由于犬分为很多种类,他们吼叫和吃饭的方式不一样,在描述的时候不能具体化,也就是吼叫和吃饭的行为不能明确。当描述行为时,行为的具体动作不能明确,这时,可以将这个行为写为抽象行为,那么这个类也就是抽象类。可是当缉毒犬有其他额外功能时,而这个功能并不在这个事物的体系中。这时可以让缉毒犬具备犬科自身特点的同时也有其他额外功能,可以将这个额外功能定义接口中。如下代码演示:interface 缉毒{ public abstract void 缉毒(); }//定义犬科的这个提醒的共性功能abstract class 犬科{public abstract void 吃饭();public abstract void 吼叫();}// 缉毒犬属于犬科一种,让其继承犬科,获取的犬科的特性,//由于缉毒犬具有缉毒功能,那么它只要实现缉毒接口即可,这样即保证缉毒犬具备犬科的特性,也拥有了缉毒的功能class 缉毒犬 extends 犬科 implements 缉毒{ public void 缉毒() { } void 吃饭() { } void 吼叫() { } }class 缉毒猪 implements 缉毒{ public void 缉毒() { } }相同点:l 都位于继承的顶端,用于被其他类实现或继承;l 都不能直接实例化对象;l 都包含抽象方法,其子类都必须覆写这些抽象方法;区别:l 抽象类为部分方法提供实现,避免子类重复实现这些方法,提高代码重用性;接口只能包含抽象方法;l 一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口;(接口弥补了Java的单继承)l 抽象类是这个事物中应该具备的内容, 继承体系是一种 is..a关系l 接口是这个事物中的额外内容,继承体系是一种 like..a关系二者的选用:l 优先选用接口,尽量少用抽象类;l 需要定义子类的行为,又要为子类提供共性功能时才选用抽象类; 8、多态多态体现为父类引用变量可以指向子类对象。多态的前提是必须有子父类关系或者类实现接口关系,否则无法完成多态。在使用多态后的父类引用变量调用方法时,会调用子类重写后的方法。 如Student类可以为Person类的子类。那么一个Student对象既可以赋值给一个Student类型的引用,也可以赋值给一个Person类型的引用 9、接口的多继承多个接口之间可以使用extends进行继承。interface Fu1{ void show(); }interface Fu2{ void show1(); }interface Fu3{ void show2(); }interface Zi extends Fu1,Fu2,Fu3{ void show3(); } 10、extends 继承Implements 实现 11、多态的定义与使用格式多态的定义格式:就是父类的引用变量指向子类对象父类类型 变量名 = new 子类类型();变量名.方法名();l 普通类多态定义的格式父类 变量名 = new 子类();如: class Fu {} class Zi extends Fu {} //类的多态使用 Fu f = new Zi();l 抽象类多态定义的格式抽象类 变量名 = new 抽象类子类();如: abstract class Fu { public abstract void method(); } class Zi extends Fu { public void method(){ System.out.println(“重写父类抽象方法”); } }//类的多态使用Fu fu= new Zi();l 接口多态定义的格式接口 变量名 = new 接口实现类();如: interface Fu { public abstract void method(); }class Zi implements Fu { public void method(){ System.out.println(“重写接口抽象方法”); } }//接口的多态使用Fu fu = new Zi();l 注意事项同一个父类的方法会被不同的子类重写。在调用方法时,调用的为各个子类重写后的方法。如 Person p1 = new Student(); Person p2 = new Teacher(); p1.work(); //p1会调用Student类中重写的work方法 p2.work(); //p2会调用Teacher类中重写的work方法当变量名指向不同的子类对象时,由于每个子类重写父类方法的内容不同,所以会调用不同的方法。 12、多态中成员变量的特点 多态中,成员特点 成员变量: 编译的时候, 参考父类中有没有这个变量,如果有,编译成功,没有编译失败 运行的时候, 运行的是父类中的变量值 编译运行全看父类 成员方法: 编译的时候, 参考父类中有没有这个方法,如果有,编译成功,没有编译失败 运行的时候, 运行的是子类的重写方法 编译看父类,运行看子类如下代码 class Fu { int num = 4; }class Zi extends Fu { int num = 5; }class Demo { public static void main(String[] args) { Fu f = new Zi(); System.out.println(f.num);//输出4 Zi z = new Zi(); System.out.println(z.num);//输出5 } }l 多态成员变量 当子父类中出现同名的成员变量时,多态调用该变量时: 编译时期:参考的是引用型变量所属的类中是否有被调用的成员变量。没有,编译失败。 运行时期:也是调用引用型变量所属的类中的成员变量。 简单记:编译和运行都参考等号的左边。编译运行看左边。 13、多态中成员方法的特点class Fu { int num = 4; void show() { System.out.println("Fu show num"); } }class Zi extends Fu { int num = 5; void show() { System.out.println("Zi show num"); } }class Demo { public static void main(String[] args) { Fu f = new Zi(); f.show(); } }l 多态成员方法编译时期:参考引用变量所属的类,如果没有类中没有调用的方法,编译失败。运行时期:参考引用变量所指的对象所属的类,并运行对象所属类中的成员方法。简而言之:编译看左边,运行看右边。 14、instanceof关键字我们可以通过instanceof关键字来判断某个对象是否属于某种数据类型。如学生的对象属于学生类,学生的对象也属于人类。 用于比较引用类型使用格式:boolean b = 对象 instanceof 数据类型; 如 Person p1 = new Student(); // 前提条件,学生类已经继承了人类 boolean flag = p1 instanceof Student; //flag结果为true boolean flag2 = p2 instanceof Teacher; //flag结果为false /* 运算符比较运算符, 结果真假值 关键字, instanceof, 比较引用数据类型 Person p = new Student(); p = new Teacher() 关键字 instanceof 比较, 一个引用类型的变量,是不是这个类型的对象 p变量,是Student类型对象,还是Teacher类型对象 引用变量 instanceof 类名 p instanceof Student 比较,p是不是Student类型的对象,如果是,intanceof返回true */ public class Test { public static void main(String[] args) { Person p = new Student(); // Person p = new Teacher(); boolean b = p instanceof Student; System.out.println(b); //b = p instanceof Animal; //System.out.println(b); p.sleep(); } } 15、多态的向上转型 16、多态的向下转型父类类型强制转换为子类类型,调用子类特有的功能 17、总结下封装、继承、多态的作用:l 封装:把对象的属性与方法的实现细节隐藏,仅对外提供一些公共的访问方式l 继承:子类会自动拥有父类所有可继承的属性和方法。l 多态:配合继承与方法重写提高了代码的复用性与扩展性;如果没有方法重写,则多态同样没有意义。 18、笔记本电脑案例 1. 案例介绍 定义USB接口(具备开启功能、关闭功能),笔记本要使用USB设备,即笔记本在生产时需要预留可以插入USB设备的USB接口,即就是笔记本具备使用USB设备的功能,但具体是什么USB设备,笔记本并不关心,只要符合USB规格的设备都可以。鼠标和键盘要想能在电脑上使用,那么鼠标和键盘也必须遵守USB规范,不然鼠标和键盘的生产出来无法使用 进行描述笔记本类,实现笔记本使用USB鼠标、USB键盘 l USB接口,包含开启功能、关闭功能l 笔记本类,包含运行功能、关机功能、使用USB设备功能l 鼠标类,要符合USB接口l 键盘类,要符合USB接口 1. 案例需求分析 阶段一: 使用笔记本,笔记本有运行功能,需要笔记本对象来运行这个功能 阶段二: 想使用一个鼠标,又有一个功能使用鼠标,并多了一个鼠标对象。 阶段三: 还想使用一个键盘 ,又要多一个功能和一个对象 问题:每多一个功能就需要在笔记本对象中定义一个方法,不爽,程序扩展性极差。 降低鼠标、键盘等外围设备和笔记本电脑的耦合性。 1. 实现代码步骤 l 定义鼠标、键盘,笔记本三者之间应该遵守的规则 interface USB { void open();// 开启功能 void close();// 关闭功能 } l 鼠标实现USB规则 class Mouse implements USB { public void open() { System.out.println("鼠标开启"); } public void close() { System.out.println("鼠标关闭"); } } l 键盘实现USB规则 class KeyBoard implements USB { public void open() { System.out.println("键盘开启"); } public void close() { System.out.println("键盘关闭"); } } l 定义笔记本 class NoteBook { // 笔记本开启运行功能 public void run() { System.out.println("笔记本运行"); } // 笔记本使用usb设备,这时当笔记本对象调用这个功能时,必须给其传递一个符合USB规则的USB设备 public void useUSB(USB usb) { // 判断是否有USB设备 if (usb != null) { usb.open(); usb.close(); } } public void shutDown() { System.out.println("笔记本关闭"); } } public class Test { public static void main(String[] args) { // 创建笔记本实体对象 NoteBook nb = new NoteBook(); // 笔记本开启 nb.run(); // 创建鼠标实体对象 Mouse m = new Mouse(); // 笔记本使用鼠标 nb.useUSB(m); // 创建键盘实体对象 KeyBoard kb = new KeyBoard(); // 笔记本使用键盘 nb.useUSB(kb); // 笔记本关闭 nb.shutDown(); } } 19、知识点总结 l 接口:理解为是一个特殊的抽象类,但它不是类,是一个接口 n 接口的特点: 1,定义一个接口用interface关键字 interface Inter{} 2,一个类实现一个接口,实现implements关键字 class Demo implements Inter{} 3, 接口不能直接创建对象 通过多态的方式,由子类来创建对象,接口多态 n 接口中的成员特点: 成员变量: 只能是final 修饰的常量 默认修饰符: public static final 构造方法: 无 成员方法: 只能是抽象方法 默认修饰符: public abstract n 类与类,类与接口,接口与接口之间的关系 类与类之间:继承关系,单继承,可以是多层继承 类与接口之间: 实现关系,单实现,也可以多实现 接口与接口之间:继承关系,单继承,也可以是多继承 Java中的类可以继承一个父类的同时,实现多个接口 l 多态:理解为同一种物质的多种形态 n 多态使用的前提: 1,有继承或者实现关系 2,要方法重写 3,父类引用指向子类对象 n 多态的成员访问特点: 方法的运行看右边,其他都看左边 n 多态的好处: 提高了程序的扩展性 n 多态的弊端: 不能访问子类的特有功能 n 多态的分类 u 类的多态 abstract class Fu { public abstract void method(); } class Zi extends Fu { public void method(){ System.out.println(“重写父类抽象方法”); } } //类的多态使用 Fu fu= new Zi(); u 接口的多态 interface Fu { public abstract void method(); } class Zi implements Fu { public void method(){ System.out.println(“重写接口抽象方法”); } } //接口的多态使用 Fu fu = new Zi(); l instanceof 关键字 格式: 对象名 instanceof 类名 返回值: true, false 作用: 判断指定的对象 是否为 给定类创建的对象

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

JAVA学习day10

1、继承继承的定义格式和使用格式:class 子类 extends 父类 {} 2、子类在继承父类的时候,会自动拥有父类的成员接下来通过一个案例来学习子类是如何继承父类的,如下所示。Example01.java/* 定义员工类Employee*/ class Employee { String name; // 定义name属性 // 定义员工的工作方法 public void work() { System.out.println("尽心尽力地工作"); } } /* 定义研发部员工类Developer 继承 员工类Employee*/ class Developer extends Employee { // 定义一个打印name的方法 public void printName() { System.out.println("name=" + name); } } /* 定义测试类*/ public class Example01 { public static void main(String[] args) { Developer d = new Developer(); // 创建一个研发部员工类对象 d.name = "小明"; // 为该员工类的name属性进行赋值 d.printName(); // 调用该员工的printName()方法 d.work(); // 调用Developer类继承来的work()方法 } }在上述代码中,Developer类通过extends关键字继承了Employee类,这样Developer类便是Employee类的子类。从运行结果不难看出,子类虽然没有定义name属性和work()方法,但是却能访问这两个成员。这就说明,子类在继承父类的时候,会自动拥有父类的成员。 3、继承的好处&注意事项继承的好处:1、继承的出现提高了代码的复用性,提高软件开发效率。2、继承的出现让类与类之间产生了关系,提供了多态的前提。在类的继承中,需要注意一些问题,具体如下: 1、在Java中,类只支持单继承,不允许多继承,也就是说一个类只能有一个直接父类,例如下面这种情况是不合法的。class A{} class B{} class C extends A,B{} // C类不可以同时继承A类和B类 多继承有安全问题 2、多个类可以继承一个父类,例如下面这种情况是允许的。 class A{} class B extends A{} class C extends A{} // 类B和类C都可以继承类A  3、在Java中,多层继承是可以的,即一个类的父类可以再去继承另外的父类,例如C类继承自B类,而B类又可以去继承A类,这时,C类也可称作A类的子类。下面这种情况是允许的。 class A{} class B extends A{} // 类B继承类A,类B是类A的子类 class C extends B{} // 类C继承类B,类C是类B的子类,同时也是类A的子类  4、在Java中,子类和父类是一种相对概念,也就是说一个类是某个类父类的同时,也可以是另一个类的子类。例如上面的这种情况中,B类是A类的子类,同时又是C类的父类。 4、继承后,子类父类中,成员变量的特点子类的对象,调用成员变量 子类自己有,就用自己的 子类没有,调用父类的 在子类中,如果想要调用父类的成员,关键字super.调用父类的成员子类继承父类(超类,基类)this.调用自己本类成员super.调用的自己的父类成员 l 子父类中成员方法的特点 当在程序中通过对象调用方法时,会先在子类中查找有没有对应的方法,若子类中存在就会执行子类中的方法,若子类中不存在就会执行父类中相应的方法。 class Fu{ public void show(){ System.out.println("Fu类中的show方法执行"); } }class Zi extends Fu{ public void show2(){ System.out.println("Zi类中的show2方法执行"); } }public class Test{ public static void main(String[] args) { Zi z = new Zi(); z.show(); //子类中没有show方法,但是可以找到父类方法去执行 z.show2(); } } 5、子类重写父类的方法 方法重写(覆盖)的应用: 当子类需要父类的功能,而功能主体子类有自己特有内容时,可以重写父类中的方法,这样,即沿袭了父类的功能,又定义了子类特有的内容。 6、覆盖的注意事项重写需要注意的细节问题: 1) 子类方法覆盖父类方法,必须要保证权限大于等于父类权限。 class Fu(){ void show(){} public void method(){} }class Zi() extends Fu{public void show(){} //编译运行没问题 void method(){} //编译错误 } 2) 写法上稍微注意:必须一模一样:方法的返回值类型 方法名 参数列表都要一样。 总结:当一个类是另一个类中的一种时,可以通过继承,来继承属性与功能。如果父类具备的功能内容需要子类特殊定义时,进行方法重写。

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

JAVA学习day08

1、快捷键 Alt+/ 自动补全 写程序的时候,之写出一部分 输出 syso 类名 Scanner 起名字 如Int 按下alt+/会帮你带出变量 Ctrl+Shift+F 代码格式化 Ctrl+/ 单行注释 取消单行注释就再按一次 Ctrl+Shift+/ 多行注释 Ctrl+Shift+\ 取消多行注释 Ctrl+Shift+o 导入包的快捷键 Alt+上下箭头 移动当前行代码 Ctrl+alt+上下箭头 复制当前代码行 Ctrl+D 删除当前行 Ctrl+1 意见提示功能 2、调试代码 • 断点: 就是一个标记 • 如何设置断点 ○ 代码区域左边的空白位置 双击即可 • 在哪里加 ○ 想看哪个语句的执行结果就在该语句前面加 • 怎么运行断点的程序 ○ 代码区域右键 -- Debug as -- Java Application ○ 显示一个页面,提示是否进入调试页面? 是否记住当前操作?是(Yes)是(勾选复选框) • 弹出了断点页面 ○ 点哪里 § 点击 工具栏中的Step Over (执行下一行) § 快捷键F6 看到每一步程序的执行过程 ○ 看哪里 § 看代码区域: 对照看程序执行步骤 § 看Debug区域: 对照看程序执行步骤 § 看varable区域: 观察变量的创建、复制、销毁 ○ 如何消除断点 § 把设置断点的方式再执行一遍 § 切换到Debug视图,选择 Breakpoints -- Remove All Breakpoints 就是2个XX的图标 3、超市管理系统案例分析 首先需要一个功能菜单,然后输入功能序号后,调用序号对应的功能方法,实现想要的操作。分析步骤如下 ○ 1.完成超市商品初始化。创建商品,将商品添加到集合 ○ 2.显示来到超市能做的操作,也就是显示主菜单 ○ 3.根据接收到的功能选项,执行对应的功能 ○ 3.1.库存货物查询 ○ 3.2.添加新货物 ○ 3.3.删除货物 ○ 3.4.修改货物 ○ 3.5.退出系统,结束main方法的运行 ○ 4.循环,回到 2.显示主菜单 定义FruitItem类 packagecom.ghy.studyday08; /* 自定义类,描述商品信息 商品的属性 编号int 品名Strint 价格double 数量Int 总价double */ publicclassFruitItem{ //商品ID intID; // Stringname; // doubleprice; // intnumber; // doublemoney; } 定义Shopp类 packagecom.ghy.studyday08; importjava.util.ArrayList; importjava.util.Scanner; /* 超市管理系统主页 实现: 1、商品数据的初始化 2、用户的菜单选择 3、根据选择执行不同的功能 3.1Read查看商品 3.2Create创建商品 3.3Delete删除商品 3.4Update更新商品 所有功能,必须定义方法实现 主方法main调用作用 */ publicclassShopp{ publicstaticvoidmain(String[]args){ //创建ArrayList集合,存储商品类型,存输出剧类型FruitItemleixing ArrayList<FruitItem>array=newArrayList<FruitItem>(); //调用商品初始化方法,传递集合 init(array); while(true){ mainMenu(); intchoose=chooseFunction(); switch(choose){ case1: showFruitList(array); break; case2: addFruitItem(array); break; case3: deleteFruit(array); break; case4: updateFruit(array); break; case5: return; default: System.out.println("输入的序号没有"); break; } } } /** *定义方法,实现主菜单 *提示用户哪些选择,选择序号 *返回值:无 *参数:无 * * */ publicstaticvoidmainMenu(){ System.out.println(); System.out.println("===========欢迎光临ITCast超市======================"); System.out.println("1、货物清单2、添加货物3、删除货物4、更新货物5、退出"); System.out.println("请您输入要操作的功能序号"); } /** *定义方法,实现接受用户的键盘输入 *返回编号 */ publicstaticintchooseFunction(){ Scannersc=newScanner(System.in); returnsc.nextInt(); } /** *定义方法,实现显示货物清单的功能 *返回值:无 *参数:集合 *遍历集合,获取集合中的每个FruitItem变量 *变量.调用属性 */ publicstaticvoidshowFruitList(ArrayList<FruitItem>array){ System.out.println(); System.out.println("==========商品库存清单========================="); System.out.println("商品编号商品名称商品单价"); //遍历集合 for(inti=0;i<array.size();i++){ //集合get方法,获取出每个FruitItem的变量,可以使用FruitItem接受get结果 FruitItemitem=array.get(i); //变量item调用类属性 System.out.println(item.ID+""+item.name+""+item.price); } } /** * */ /** *定还是那个方法,实现商品数据的初始化 *先将一部分数据,存储到集合中 *返回值:无 *参数:集合 *方法名:init * */ publicstaticvoidinit(ArrayList<FruitItem>array){ //创建出多个FruitItem类型,并且属性赋值 FruitItemf1=newFruitItem(); f1.ID=9527; f1.name="烧饼"; f1.price=12.7; FruitItemf2=newFruitItem(); f2.ID=9528; f2.name="米粉"; f2.price=22; FruitItemf3=newFruitItem(); f3.ID=9830; f3.name="新疆大盘鸡"; f3.price=100.6; //将创建的3个FriutItem类型的变量,存储到集合中 array.add(f1); array.add(f2); array.add(f3); } /** *定义方法,实现商品的添加功能 *返回值:无 *参数:集合 *提示用户选择的是商品的功能 * *提示用户输入的是什么 * *创建FruitItem变量,变量调用的属性 *将输入的每个商品属性进行赋值 * */ publicstaticvoidaddFruitItem(ArrayList<FruitItem>array){ System.out.println("您选择的是添加商品功能"); //创建Scanner变量 Scannersc=newScanner(System.in); System.out.println("请输入商品的编号"); //输入商品的编号 intID=sc.nextInt(); //输入商品的名字 System.out.println("请输入商品的名字"); Stringname=sc.next(); //输入商品的单价 System.out.println("请输入商品的单价"); doubleprice=sc.nextDouble(); //创建FruitItem的变量 FruitItemitem=newFruitItem(); item.ID=ID; item.name=name; item.price=price; array.add(item); } /* *定义方法,实现商品的修改功能 *返回值:无 *参数: 集合 * *提示用户选择的是修改功能 *提示用户输入需要修改的商品编号 *遍历集合,获取每个FruitItem变量 *变量调用ID属性,属性和用户输入的编号比较 *如果相同: *修改调FruitItem中的属性值 *键盘输入 */ publicstaticvoidupdateFruit(ArrayList<FruitItem>array){ System.out.println("选择的是修改功能"); System.out.println("请输入商品的编号"); Scannersc=newScanner(System.in); intID=sc.nextInt(); //遍历集合,获取每个FruitItem变量 for(inti=0;i<array.size();i++){ FruitItemitem=array.get(i); //获取FruitItem的属性ID,和用户输入的ID比较 if(item.ID==ID){ System.out.println("输入新的商品编号"); item.ID=sc.nextInt(); System.out.println("输入新的商品名字"); item.name=sc.next(); System.out.println("输入新的商品价格"); item.price=sc.nextDouble(); System.out.println("商品修改成功"); return; } } System.out.println("输入的编号不存在"); } /** *定义方法,实现商品的删除功能 *返回值:无 *参数:集合 * *删除依靠的是商品的编号 *提示用户选择的是删除功能 *键盘输入商品的编号 *遍历集合,获取集合中的每个FruitItem变量 *变量调用属性ID,和用户的输入的编号,对比,相同就删除 */ publicstaticvoiddeleteFruit(ArrayList<FruitItem>array){ System.out.println("选择的是删除功能"); System.out.println("请输入商品的编号"); Scannersc=newScanner(System.in); intID=sc.nextInt(); //遍历集合 for(inti=0;i<array.size();i++){ //获取到每个FruitItem变量 FruitItemitem=array.get(i); //变量,调用属性ID,和用户输入的编号比较 if(item.ID==ID){ //移除集合中的元素 //集合的方法remove实现 array.remove(i); System.out.println("删除成功"); return; } } System.out.println("你输入的编号不存在"); } }

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

JAVA学习day09

1、面向过程与面向对象的思想面向对象: 我该让谁来做面向过程: 我该怎么做 2、大象装冰箱我们把大象装冰箱为例进行分析。在针对具体的需求,可以使用名词提炼的办法进行分析,寻找具体的对象。需求:把大象装冰箱里对象:大象、冰箱分三步:1、打开冰箱门2、将大象装进去3、关闭冰箱门分析发现打开、装、关闭都是冰箱的功能。即冰箱对象具备如下功能:冰箱打开冰箱存储冰箱关闭用伪代码描述,上述需求中有两个具体的事物 大象 和 冰箱描述大象:class 大象{}描述冰箱class冰箱{void 打开(){}void 存储(大象){}void 关闭(){}}当把具体的事物描述清楚之后,需要使用这些具体的事物,Java使用具体的事物,需要通过new关键字来创建这个事物的具体实例。使用对象:1、创建冰箱的对象冰箱 bx = new 冰箱(); 2、调用冰箱的功能对象.功能();bx.打开();bx.存储(new 大象());bx.关闭(); 总结:1、先按照名词提炼问题领域中的对象2、对对象进行描述,其实就是在明确对象中应该具备的属性和功能3、通过new的方式就可以创建该事物的具体对象4、通过该对象调用它以后的功能。 3、对象的内存图 方法进栈,类进堆 4、成员变量和局部变量的差别 成员变量:定义在类中的 局部变量:定义在方法中的变量 区别: 1)定义位置上的区别 成员变量:定义在类中,方法外 局部变量:定义在方法中,语句内 2)作用域不同 成员变量:作用范围是整个类 局部变量:作用范围是方法内,语句内 3)默认值不同 成员变量:有自己的默认值 局部变量:没有默认值,不赋值不能使用 4)内存位置不同 成员变量:跟着对象进入堆内存存储 局部变量:跟着方法进栈内存 5)生命周期不同 成员变量:跟着对象,在堆中存储,内存等待JVM清理 局部变量:跟着方法,方法出栈,生命周期较短 5、方法参数是基本数据类型 或 引用数据类型 public class Person { String name ;} /* 方法的参数类型,是基本数据类型,引用数据类型*/ public class TestPerson { public static void main(String[] args) { int a = 1; function(a); System.out.println(a); Person p = new Person(); p.name = "张三"; System.out.println(p.name); function(p); System.out.println(p.name); } /* * 定义方法,参数类型是引用数据类型 * 参数是Person类型 * p接受的是一个内存的地址 * main 中的变量p * function 中的变量p 保存的地址是一样的 */ public static void function(Person p){ p.name = "李四"; } /* * 定义方法,参数类型是基本数据类型 */ public static void function(int a){ a+=5; } } 6、封装 将具体功能封装到方法中,学习对象时,也提过将方法封装在类中,其实这些都是封装。 封装,它也是面向对象思想的特征之一。面向对象共有三个特征:封装,继承,多态。接下来我们具体学习封装。  封装表现:  1、方法就是一个最基本封装体。  2、类其实也是一个封装体。  从以上两点得出结论,封装的好处:  1、提高了代码的复用性。  2、隐藏了实现细节,还要对外提供可以访问的方式。便于调用者的使用。这是核心之一,也可以理解为就是封装的概念。  3、提高了安全性。 7、private关键字 新的关键字 private 私有 属于成员修饰符,不能修饰局部变量 被private修饰的成员,只能在自己的本类中被使用 cn.itcast.demo04; /* 描述现实生活中的人的事物 属性: 姓名 年龄 功能: 说话 出现安全问题: age问题,可能出现赋值为负数的情况 负数不会导致程序问题,违反生活中的真实情况 提高安全问题: 让外面的类,不允许直接调用我的成员变量 新的关键字 private 私有 属于成员修饰符,不能修饰局部变量 被private修饰的成员,只能在自己的本类中被使用 对私有变量,提供公共的访问方式: 方法*/ public class Person { //人的姓名,成员变量 String name; //人的年龄,成员变量 private int age ; //变量age被私有,提供方法,让外面的类使用 //定义方法,对age变量进行赋值,方法名字,必须set开头 public void setAge(int a){ //对变量参数a进行范围的限制 if(a<0 || a > 200){ //如果a超过范围,手动将age赋值为20 age = 20; }else{ //如果a没有超过范围,直接对age赋值 age = a; } } //定义方法,对变量age获取值使用,方法名字get public int getAge(){ return age; } //定义人的说话功能,方法中,要求说出自己的姓名和年龄 public void speak(){ System.out.println(name+"..."+age); } } package cn.itcast.demo04;/* 定义好的Person类进行测试 创建对象,对象调用属性和方法*/ public class PersonTest { public static void main(String[] args) { //创建Person类的对象 new Person p = new Person(); //对成员变量赋值 //p.age = -200; //对成员变量age赋值,只能调用Set方法赋值 p.setAge(50); p.name = "张三"; //调用类中方法 p.speak(); //输出成员变量age值,必须调用get方法 System.out.println(p.getAge()); } }  总结: 类中不需要对外提供的内容都私有化,包括属性和方法。 以后再描述事物,属性都私有化,并提供setXxx getXxx方法对其进行访问。 8、私有化Person类带get,set 私有化所有的属性(成员变量),必须有对应的get与set方法 凡是自定义的类,都必须有get与set方法 package cn.itcast.demo05; /* 类描述人: 属性: 姓名和年龄 方法: 说话 私有化所有的属性 (成员变量) ,必须写对应的get/set方法 凡是自定义的类,自定义成员变量,应该私有化,提供get/set this关键字: 区分成员变量和局部变量同名情况 方法中,方位成员变量,写this.*/ public class Person { private String name; private int age; // set方法,变量name,age赋值 public void setAge(int age) { this.age = age; } public void setName(String name) { this.name = name; } // get方法,变量name,age获取值 public int getAge() { return age; } public String getName() { return name; } public void speak() { String name = "哈哈"; int age = 16; System.out.println("人在说话 " + this.name + "..." + this.age); } } public class PersonTest { public static void main(String[] args) { Person p = new Person(); //调用set方法,对成员变量赋值 p.setAge(18); p.setName("旺财"); p.speak(); //调用get方法,获取成员变量的值 // System.out.println(p.getName());// System.out.println(p.getAge()); } } 9、this关键字——用于解决成员变量和局部变量的重名问题方法中的局部变量和类中的成员变量,采用就近原则进行变量获取由于存在成员变量和局部变量同名的情况,此时需要this关键字所有this.的变量都是类中的成员变量 10、知识点总结 类与对象 类,用于描述多个对象的共同特征,它是对象的模板。 对象,用于描述现实中的个体,它是类的实例。 类的定义:使用关键字class来定义java中的类 格式: class 类名 { //属性 数据类型 变量名; … //方法 修饰符 返回值类型 方法名(参数){ } … }  创建对象: 格式:类名 对象名 = new 类名(); 封装(private关键字) 封装,把对象的属性与方法的实现细节隐藏,仅对外提供一些公共的访问方式 封装的体现: 变量:使用 private 修饰,这就是变量的封装 方法:也是一种封装,封装了多条代码 类: 也是一种封装,封装了多个方法 private关键字,私有的意思 它可以用来修饰类中的成员(成员变量,成员方法) private的特点: private修饰的成员只能在当前类中访问,其他类中无法直接访问 this关键字 this关键字,本类对象的引用 this是在方法中使用的,哪个对象调用了该方法,那么,this就代表调用该方法的对象引用 this什么时候存在的?当创建对象的时候,this存在的 this的作用:用来区别同名的成员变量与局部变量(this.成员变量) public void setName(String name) { this.name = name; }

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

JAVA学习day07

1、奇数求和练习packagecom.ghy.studyday07; /*要求:计算1-100之间的所有的奇数和1+3+5+7...+99 有1个数据,从0变到100循环int=0<=100++从0-100,范围内,找到奇数数%2==1奇数所有的奇数求和计算需要变量,保存奇数的求和 实现步骤:1.程序可以使用到的数据,预先定义好变量需要求的奇数和2.利用循环,让变量从0变化到1003.判断变量的变化情况是不是奇数4.如果是奇数,和预先定义好的变量,求和*/publicclassLoopTest{publicstaticvoidmain(String[]args){//定义变量,保存求和intsum=0;//for循环,循环中的变量,0-100for(inti=0;i<=100;i++){//对循环的变量,进行奇数的判断,%2==1if(i%2==1){//对奇数求和sum+=i;}}System.out.println(sum); //sum=0; /*for(inti=1;i<=100;i+=2){sum+=i;}System.out.println(sum);*/}} 2、计算出水仙花数即 3位数本身 = 百位数立方 + 十位数立方 + 个位数立方三位数100-999个位数的立方+十位数的立方+百位数的立方=自己本身153=111+555+333已知三位数123获取出每个数位利用除法,取模运算 实现步骤:1.定义变量才存储三个数位上的整数2.利用循环,循环中的变量,从100变化到9993.循环中得到三位数,利用算法,拆解成三个单独数位4.将三个数位立方的求和计算,计算后的求和,和他自己进行比较判断相同,就是水仙花publicclassLoopTest_1{publicstaticvoidmain(String[]args){//定义三个变量intbai=0;intshi=0;intge=0; //循环,循环变量从100-999for(inti=100;i<1000;i++){//对i,进行计算,获取出三个数位//获取百位bai=i/100;//获取十位shi=i/10%10;//获取个位ge=i%10;//对三个数位进行立方求和if(baibaibai+shishishi+gegege==i){System.out.println(i);}}}} 3、ASCII编码表数字0-9对应ASCII编码十进制为48-57, 字母a-z对应ASCII编码十进制为97-122,字母A-Z对应ASCII编码十进制为65-90 4、利用for循环打印字母表 /*利用循环,输出字母包含大写小写,52个输出A-Za-z利用编码表实现,字母和数字的对应关系A-Z65-90a-z97-122 实现步骤:1.定义变量,保存小写a,大写A2.循环26次,输出定义好的变量每次循环,变量++*/publicclassLoopTest_2{publicstaticvoidmain(String[]args){//定义变量,保存2个字母charxiaoXie='a';chardaXie='A';//定义循环,次数26次for(inti=0;i<26;i++){//输出保存字母的变量System.out.println(xiaoXie+""+daXie);daXie++;xiaoXie++;}}} 5、利用for循环打印9*9表for循环的特点: 外循环,行数 内循环,每行的个数 /*利用嵌套for循环,实现99乘法表示实现步骤:1.定义外循环控制行数2.内循环控制个数,个数,每次都在递增3.循环中输出,乘法表的格式1*3=3*/publicclassLoopTest_3{publicstaticvoidmain(String[]args){print99(9);} publicstaticvoidprint99(intn){//定义外循环,循环9次for(inti=1;i<=n;i++){//定义内循环,每次递增,循环条件,<=ifor(intj=1;j<=i;j++){//按照标准格式,输出打印System.out.print(j+""+i+"="+ij+"t");}System.out.println();}}} 6、实现数组的遍历 7、数组的逆序 不等于反向遍历 逆序的实现思想,数组最远端位置的交换 数组的指针思想: 就是数组的索引 指针是可以随时指向数组的任意一个索引的 需要两个指针 一个大指针,一个小指针 大指针=最大索引 小指针=0索引 8、选择排序原理selectSort数组中的每个元素,和其他元素进行比较换位置 元素换位需要借助第三方变量packagecom.ghy.studyday07; /*数组的排序:一般都是升序排列,元素,小到大的排列 两种排序的方式选择排序:数组的每个元素都进行比较冒泡排序:数组中相邻元素进行比较规则:比较大小,位置交换*/publicclassArrayMethodTest_2{publicstaticvoidmain(String[]args){int[]arr={3,1,4,2,56,7,0};//调用选择排序方法//selectSort(arr); //调用冒泡排序方法bubbleSort(arr);printArray(arr);}/*定义方法,实现数组的冒泡排序返回值:没有参数:数组*/publicstaticvoidbubbleSort(int[]arr){for(inti=0;i//每次内循环的比较,从0索引开始,每次都在递减for(intj=0;j//比较的索引,是j和j+1if(arr[j]>arr[j+1]){inttemp=arr[j];arr[j]=arr[j+1];arr[j+1]=temp;}}}} /*定义方法,实现数组的选择排序返回值:没有参数:数组实现步骤:1.嵌套循环实现排序外循环,控制的是一共比较了多少次内循环,控制的是每次比较了多少个元素2.判断元素的大小值小值,存储到小的索引*/publicstaticvoidselectSort(int[]arr){for(inti=0;i//内循环,是每次都在减少,修改变量的定义for(intj=i+1;j//数组的元素进行判断if(arr[i]>arr[j]){//数组的换位inttemp=arr[i];arr[i]=arr[j];arr[j]=temp;}}}} /*定义方法,实现功能返回值:void方法参数:数组*/publicstaticvoidprintArray(int[]arr){//输出一半中括号,不要换行打印System.out.print("[");//数组进行遍历for(inti=0;i//判断遍历到的元素,是不是数组的最后一个元素//如何判断循环变量到达length-1if(i==arr.length-1){//输出数组的元素和]System.out.print(arr[i]+"]");}else{//不是数组的最后一个元素,输出数组元素和逗号System.out.print(arr[i]+",");}}System.out.println();}} 9、冒泡排序功能数组的相邻元素换位置1.嵌套循环实现排序外循环,控制的是一共比较了多少次内循环,控制的是每次比较了多少个元素10、数组的折半查找前提:被查找的数组中的元素,必须有序排列

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

JAVA学习day06

1、3种引用类型 1、数组 2、类 3、接口 2、定义类: 使用类的形式,对现实中的事物进行描述 事物:方法,属性 方法:这个事物具备的功能 属性:变量 格式: Public class 类名{ 属性定义 修饰符 数据类型 变量名 =值 方法定义 修饰符 返回值类型 方法名(参数列表){ } } 3、创建引用类型的变量的格式 数据类型 变量名 =new 数据类型(); 4、实现引用类型的步骤 1、导入包;如果类都是在同一个文件夹,不需要导入包; 2、创建引用类型的变量 3、变量.类型中的功能(也可以调用类中的属性,属性就是变量,赋值和获取值) 测试手机类: /* 定义类: 使用类的形式,对现实中的事物进行描述 事物: 方法,属性 方法: 这个事物具备的功能 属性: 变量 格式: public class 类名{ 属性定义 修饰符 数据类型 变量名 = 值 方法定义 修饰符 返回值类型 方法名(参数列表){ } } 要求: 使用Java中的类,描述生活中的手机这个事物 手机事物,具备哪些属性, 属于他自己的特性 颜色,品牌, 大小 */ public class Phone{ /* 定义手机的属性 */ String color ; String brand ; double size ; } 测试手机类: /* 测试,刚定义好的Phone类 创建引用类型变量的格式 数据类型 变量名 = new 数据类型(); 实现引用类型的步骤 1: 导入包 , 类都是在同一个文件夹,不需要导入包 2: 创建引用类型的变量 3: 变量.类型中的功能 */ public class TestPhone{ public static void main(String[] args){ // 2: 创建引用类型的变量 Phone p = new Phone(); //System.out.println(p); //输出内存的地址 //3: 变量.类型中的功能 //变量 p.的方式,调用类中的属性 //属性就是变量 , 赋值和获取值 p.color = "土豪金"; p.brand = "爱立信"; p.size = 5.0; //获取属性值 System.out.println(p.color+" "+p.brand+" "+p.size); } } 4、程序运行流程 1、方法先进方法区,数据共享区 2、运行时,进入栈 3、引用相关进入堆 5、两个引用类型变量内存图 6、类的练习 电饭锅,包含属性(品牌、容量大小、颜色等) 定义类,描述事物,电饭锅 属性:品牌,大小,颜色 定义类,类名字,电饭锅 类的范围,定义三个属性 7、ArrayList——ArrayList集合的使用 也是引用数据类型 步骤: 1. 导入包 java.util包中 2. 创建引用类型的变量 数据类型< 集合存储的数据类型> 变量名 = new 数据类型 <集合存储的数据类型> (); 集合存储的数据类型: 要将数据存储到集合的容器中 创建集合引用变量的时候,必须要指定好,存储的类型是什么 ArrayList<String> array = new ArrayList<String>(); 3. 变量名.方法 注意: 集合存储的数据,8个基本类型对应8个引用类型 存储引用类型,不存储基本类型 8、ArrayList的常见方法 add(参数) 向集合中添加元素,数据存储进去 方法中的参数类型,定义集合对象时候的类型是一致 ArrayList<Integer> array = new ArrayList<Integer>(); array.add(3); get(int index) 取出集合中的元素,get方法的参数,写入索引 size() 返回集合的长度, 集合存储元素的个数 补充方法: Add(int 索引,存储的元素) 将元素添加到指定的索引上 如:array.add(2,7);//在2索引的位置添加7 set(int 索引,修改后的元素) 将指定的索引上的元素进行修改 Remove(int 索引) 删除指定索引上的元素 Clear() 清空集合中的所有元素 9、ArrayList集合的遍历 /* 集合的遍历 实现思想也是索引思想 集合的索引从0开始,到 size()-1 方法get(int index) */ import java.util.ArrayList; public class ArrayListDemo_2{ public static void main(String[] args){ ArrayList<Integer> array = new ArrayList<Integer>(); array.add(121); array.add(125); array.add(123); array.add(120); array.add(128); //对集合进行遍历 //使用方法 size+get组合进行遍历 for(int i = 0 ; i < array.size(); i++){ System.out.println( array.get(i) ); } } } 10、ArrayList存储的是类型,如商品类型/* 定义,.描述商品的类 商品 4个属性 商品名字 大小 价格 库存 String double double int 定义类,类名Goods 这个类型的变量,存储到集合中 */public class Goods{ //定义商品名字 String brand ; //大小属性 double size ; // 价格属性 double price ; //库存属性 int count ; } /* 实现库存管理案例: 1. 存储商品信息 存储商品类型变量 将商品类型的变量,存储到集合中 2. 查看库存清单 将集合进行遍历, 获取出集合中存储的Goods类型变量 输出每一个Goods类型的属性 计算求和: 总库存,总金额 3. 修改商品的库存 集合遍历 ,获取出集合中存储的Goods类型变量 变量调用Goods类的属性count,值进行修改 (键盘输入) *///import java.util.ArrayList;import java.util.*;public class Shopp{ public static void main(String[] args){ //创建ArrayList集合,存储Goods类型 ArrayList<Goods> array = new ArrayList<Goods>(); //调用添加商品信息的方法 addGoods(array); //进入死循环中 while(true){ //调用选择功能的方法,获取到用户输入的功能序号 int number = chooseFunction(); //对序号判断,如果=1 进入查看库存功能 = 2 进入修改库存功能 =3 结束 switch(number){ case 1: //进入查看库存,调用查看库存的方法,传递存储商品信息的集合 printStore(array); break; case 2: //进入修改库存功能,调用修改库存的方法,传递集合 update(array); break; case 3: return ; default: System.out.println("无此功能"); break; } } } /* 方法定义,修改库存 键盘的输入,将Goods中的属性值,修改 */ public static void update(ArrayList<Goods> array){ Scanner sc = new Scanner(System.in); //遍历集合,获取集合中的每个元素 for(int i = 0 ; i < array.size(); i++){ //集合方法get获取的是集合的元素,元素类型Goods Goods g = array.get(i); System.out.println("请输入"+g.brand+"的库存数"); //Goods属性,count进行修改 g.count = sc.nextInt(); } } /* 定义方法,实现选择菜单,用户根据功能选择菜单 */ public static int chooseFunction(){ System.out.println("-------------库存管理------------"); System.out.println("1.查看库存清单"); System.out.println("2.修改商品库存数量"); System.out.println("3.退出"); System.out.println("请输入要执行的操作序号:"); Scanner sc = new Scanner(System.in); int number = sc.nextInt(); return number; } /* 定义方法,查看库存清单,遍历集合 */ public static void printStore(ArrayList<Goods> array){ //输出表头 System.out.println("----------商场库存清单----------"); System.out.println("品牌型号 尺寸 价格 库存数"); //定义变量,保存总库存数,和总金额 int totalCount = 0 ; double totalMoney = 0; //遍历集合 for(int i = 0 ; i < array.size(); i++){ //get(索引)获取出集合中的元素,存储的是Goods类,获取的也是Goods类型 //使用Goods类型变量,接受get方法结果 Goods g = array.get(i); System.out.println(g.brand+" "+g.size+" "+g.price+" "+g.count); totalCount = totalCount+g.count; totalMoney = totalMoney + g.count*g.price; } System.out.println("总库存数: "+totalCount); System.out.println("商品库存总金额: "+totalMoney); } /* 定义方法,将商品的信息存储到集合中 集合是所有方法的共享数据,参数传递 */ public static void addGoods (ArrayList<Goods> array){ //创建商品类型变量 Goods类型的变量 Goods g1 = new Goods(); Goods g2 = new Goods(); g1.brand = "MacBook"; g1.size = 13.3; g1.price = 9999.99; g1.count = 3; g2.brand = "Thinkpad"; g2.size = 15.6; g2.price = 7999.99; g2.count = 1; //Goods类型的变量,存储到集合中 array.add(g1); array.add(g2); } }

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

JAVA学习day05

1、方法就是用来完成解决某件事件或者实现某个功能的办法。 2、方法的定义格式: 修饰符 返回值类型 方法的名字 (参数列表....){ 方法的功能主体 循环,判断,变量,比较,运算 return ; } 修饰符:固定写法 public static 返回值类型: 方法在运算后,结果的数据类型 方法名: 自定义名字,满足标识符规范,方法名字首字母为小写,后面每个单词首字母大写 参数列表: 方法的运算过程中,是否有未知的数据,如果有未知的数据,定义在参数列表上(定义变量) return: 方法的返回,将计算的结果返回,结束方法 3、调用方法:让一个方法运行起来 4、调用方法执行流程 方法参数里面的都是形参 实际调用时的参数是实参 5、方法调用的内存图 栈:先进后出 后进先出 6、方法定义和使用的注意事项 1、方法不能定义在另一个方法的里面; 2、写错方法名字; 3、写错了参数列表; 4、方法返回值是void,方法中可以省略return不写; Return 后面不能有代码; 5、方法返回值类型,和return 后面数据类型必须匹配; 6、方法重复定义问题; 7、调用方法的时候,返回值是void,不能写在输出语句中; 7、方法的重载 方法的重载特性(overload) 在同一个类中,允许出现同名的方法,只要方法的参数列表不同即可,这样方法就是重载 参数列表不同:参数的个数,数据类型,顺序 对于重载的调用,根据参数传递进行区分 8、方法重载的注意事项 1、参数列表必须不同 2、重载和参数变量名无关 3、重载和返回值类型无关 4、重载和修饰符无关 技巧:重载看方法名和参数列表 9、方法参数是基本数据类型 方法,调用中的参数传递问题 1、方法参数是基本数据类型 2、方法参数是引用类型:传递的是内存地址 10、库存练习package com.ghy.study; /* 实现商品的库存管理 功能: 1. 展示用户选择功能清单 2. 根据选择的功能编号,进行不同的操作 A. 展示所有库存 B. 修改库存数量 分析: 1. 展示用户清单: 输出语句, 用户输入, 选择功能序号 2. 根据选择,调用不同的方法 switch语句 case 1 2 3 A 展示库存 将存储商品的数组,遍历 B 修改库存 修改所有的库存数量 */import java.util.Scanner; public class ShopMethod { public static void main(String[] args){ //使用数组,保存商品的信息 //品名,尺寸,价格,库存数, 定义5个数组 String[] brand = {"MacBookAir","ThinkpadT450"}; double[] size = {13.3,15.6}; double[] price = {9998.97,6789.56}; int[] count = {0,0}; while(true){ int choose = chooseFunction(); switch(choose){ case 1: //调用查看库存清单方法 printStore(brand,size,price,count); break; case 2: //调用修改库存的方法 update(brand,count); break; case 3: return ; default: System.out.println("没有这个功能"); break; } } } /* 定义方法,修改所有商品的库存 用户输入1个,修改1个 返回值,没有 参数, 库存数的数组, 品名数组 */ public static void update(String[] brand, int[] count){ //遍历数组,遍历到一个,修改一个 //接受键盘输入 Scanner sc = new Scanner(System.in); //遍历数组 for(int i = 0; i < brand.length ; i++){ System.out.println("请输入"+brand[i]+"的库存数"); //键盘输入,录入库存, 存储到库存的数组中 int newCount = sc.nextInt(); count[i] = newCount; } //int chooseNumber = sc.nextInt(); } /* 定义方法,展示所有的库存清单,遍历 返回值,没有 参数, 数组 */ public static void printStore(String[] brand,double[] size,double[] price,int[] count){ System.out.println("----------商场库存清单----------"); System.out.println("品牌型号 尺寸 价格 库存数"); //定义变量,计算总库存数,和总价格 int totalCount = 0; int totalMoney = 0; //遍历数组,将数组中所有的商品信息打印出来 for(int i = 0 ; i < brand.length ; i++){ System.out.println(brand[i]+" "+size[i]+" "+price[i]+" "+count[i]); totalCount += count[i]; totalMoney += count[i]*price[i]; } System.out.println("总库存数: "+totalCount); System.out.println("商品库存总金额: "+totalMoney); } /* 定义方法,实现用户的选择功能,功能的需要返回来 返回值, int 参数, 没有 */ public static int chooseFunction(){ System.out.println("-------------库存管理------------"); System.out.println("1.查看库存清单"); System.out.println("2.修改商品库存数量"); System.out.println("3.退出"); System.out.println("请输入要执行的操作序号:"); //接受键盘输入 Scanner sc = new Scanner(System.in); int chooseNumber = sc.nextInt(); return chooseNumber; } }

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

JAVA学习day04

1、选择语句switch编写格式Switch( 表达式 ){ Case 常量1: 要执行的语句; Break; Case 常量2: 要执行的语句; Break; Case 常量3: 要执行的语句; Break; Default: 要执行的语句; Break; }执行流程:表达式,和case后面的常量进行比较和哪个case后的常量相同,就执行哪个case后面的程序,遇到break,就全部结束; 2、case的穿透性案例:星期1-5 工作日 星期6-7 输出休息日case 1 case 2 case 3 case 4 case 5 输出结果相同 case后面的常量,和switch中数据相同,没有break,一直向下穿透case后面没有break,程序就会一直向下穿透 3、数组数据多了存数组(原因:数据太多,定义变量,容易造成代码重复) 定义数组容器 定义数组容器,要素,强制数据类型的语言 必须要有数据类型,大小,就是存储数据的个数 定义数组公式: 数组类型 [] 变量名 = new 数据类型 [存储元素的个数] 数据类型:数组中存储元素的数据类型 [] 表示数组的意思 变量 自定义标识符 New 创建容器关键字 数据类型:数组中存储元素的数据类型 [] 表示数组的意思 元素个数,就是数组中,可以存储多少个数据(恒定,数组是定长型) 数组是一个容器:存储到数组中的每个元素,都有自己的额自动编号 自动编号,最小值是0,最大值,长度-1 自动编号专业名词,索引(index),下表,角标 访问数组存储的元素,必须依赖于索引,公式 数组名[索引] JAVA提供了一个属性,操作索引的 数组的一个属性,就是数组的长度,属性的名字 Length 使用属性: 数组名.length 数据类型 Int 数组的最小索引是0 最大索引是数组.length-1 4、JVM的内存划分 5、 其中:arr引用类型,保存的数据,实质上是内存中的地址; 6、为数组的元素赋值Arr[1]=5 7、数组的定义数组的两个定义方式 数据类型[] 变量名 = new 数据类型[]{元素1,元素2,元素3} ; Int[] arr =new int[] {1,2,3,4,5,6,7} 数据类型[] 变量名 ={匀速1,元素2,元素3}; //定义数组,直接大括号赋值这种方式推荐使用 int[]arr2={1,2,3,4,5,8}; System.out.println(arr2.length);//打印数组的长度 System.out.println(arr2[5]);//索引从0开始 8、数组的遍历 通过索引的方式将数组中的每个元素,分别获取出来 要依靠索引才能实现 //如下方式是遍历数组最常用的方式 for(inti=0;i<arr.length;i++){ System.out.println(arr[i]); } 9、数组中常见的异常 数组的索引越界异常 空指针异常 10、数组获取最值得原理思想 1)定义变量,保存在数组中 Int max =arr[0]; 2)max和数组中的其他元素进行比较 A 数组遍历 B max比其他索引上的元素小 max记录下较大的数 3)数组遍历完成后 max记录的就是数组的最大值 publicclassArrayDemo_5{ publicstaticvoidmain(String[]args){ //定义数组,Intleixing int[]arr={5,2,3,5,8,9,0,4}; //定义变量,记录数组中0索引上的元素 intmax=arr[0]; //遍历数组,获取所有的元素,和变量max比较 for(inti=1;i<arr.length;i++){ //变量max,和数组中的每个元素进行比较 //如果Max小于了数组中的一个元素,将较大的元素赋值给max if(arr[i]>max){ max=arr[i]; } } //遍历完成,变量max就是数组的最大值 System.out.println(max); } } 11、二维数组的定义 11、二维数组的定义和访问 12、二维数组的遍历 13、维数组的遍历求和 /* 二维数组的遍历求和 第一小组销售额为{11,12}万元 第二小组销售额为{21,22,23}万元 第三小组销售额为{31,32,33,34}万元。 每个小组就是一个数组,三个数组存储到一个数组中,形成二维数组 求和: 每个小组求和 所有元素求和 */ publicclassArrayArrayDemo_3{ publicstaticvoidmain(String[]args){ int[][]arr={{11,12},{21,22,23},{31,32,33,34}}; //定义变量,保存2个求和的值 intsum=0;//所有元素的求和 intgroupSum=0;//每个一维数组的求和 for(inti=0;i<arr.length;i++){ for(intj=0;j<arr[i].length;j++){ //将一维数组的元素求和 groupSum+=arr[i][j]; } System.out.println("每个小组总金额"+groupSum); //将每个一维数组的总和在相加 sum+=groupSum; //每个唯一数组求和,清空 groupSum=0; } System.out.println("本公司总金额"+sum); } } 14、随机点名器 packagecom.ghy.study; /* 随机点名器: 1存储姓名 2.预览所有人的姓名 3.随机出一个人的姓名 */ importjava.util.Random; publicclassCallName{ publicstaticvoidmain(String[]args){ //存储姓名,姓名存储到数组中 //数组存储姓名,姓名的数据类型,String String[]names={"张三","李四","王五","李蕾","韩梅梅","小名","老王","小华","约翰逊","爱丽丝"}; //预览:遍历数组,打印所有姓名 for(inti=0;i<names.length;i++){ System.out.println(names[i]); } System.out.println(names.length); System.out.println("============="); //随机出一个人的名 //利用随机数,生成一个整数,作为索引,到数组中找到对应的元素 Randomran=newRandom(); //随机数,范围必须是0-数组的最大索引 //nextInt是0-这个数,但不包含这个数 intindex=ran.nextInt(names.length);//index就是随机数,作为索引 System.out.println(names[index]); } }

资源下载

更多资源
优质分享App

优质分享App

近一个月的开发和优化,本站点的第一个app全新上线。该app采用极致压缩,本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

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应用均可从中受益。

Sublime Text

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能,例如代码缩略图,Python的插件,代码段等。还可自定义键绑定,菜单和工具栏。Sublime Text 的主要功能包括:拼写检查,书签,完整的 Python API , Goto 功能,即时项目切换,多选择,多窗口等等。Sublime Text 是一个跨平台的编辑器,同时支持Windows、Linux、Mac OS X等操作系统。

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