认识类和对象
类：具有相同属性和方法的一组对象的集合，类是对象的抽象，对象是类的具体. 模板：上面写属性，下面写方法
定义类： 1.定义类名字 2.编写类的属性 3.编写类的方法
创建和使用对象
使用对象的步骤:
创建对象: 类名 对象名 =new 类名();
引用对象成员: 使用 " " 进行以下操作 引用类的属性:对象名.属性 引用类的方法:对象名.方法名()
如何使用带参数的方法
定于带参数的方法：
<访问修饰符>返回类型<方法名>(<形式参数列表>){ //方法的主体 }
调用带参数的方法：
对象名.方法名(参数1,参数2,..........参数n、) 。参数为实参列表
注意事项:
方法定义处的参数叫形式参数(形参),方法调用处传的值叫实际参数(实参)。 带参方法,参数个数可以有一个,也可以有多个,多个参数之间用逗号隔开。 带参方法,参数名字可以随意取,符合变量命名规则。 形参和实参名字可以不一样
基本数据类型传递和引用数据传递(相当于地址传进去了)
类和对象：
类：具有相同属性和方法的一组对象的集合 类是对象的抽象，对象是类的具体 使用对象的步骤
创建对象
类名 对象名 = new 类名（）； 引用对象成员：使用“.”进行以下操作 引用类的属性：对象名.属性 引用类的方法：对象名.方法名（）；
如何使用带参数的方法
定义带参数的方法 <访问修饰符>返回类型<方法名>(<形式参数列表>){ //方法的主题 } 调用带参数的方法 对象名.方法名(参数1，参数2，参数n) 注意事项：形参和实参名字可以不一样，但是数据类型要一致，个数要一样，顺序要一样 构造方法与普通方法区别
1.构造方法没有返回值类型
2.方法名与类名相同
作用 对象初始化 this关键字的用法 1.调用属性2.调用方法3.调用构造方法（如果使用，必须是构造方法中的第一条语句） 方法重载 1.同一个类中，方法名相同2.参数项不同3.与返回值、访问修饰符无关 如何实现封装 1.修改属性的可见性（设为private，防止错误的修改） 2.创建公有的getter/setter方法（用于属性的读写） 3.在getter/setter方法中加入属性控制语句（对属性值的合法性进行判断） String equals（）：检查组成字符串内容的字符是否完全一致 ==：判断两个字符串在内寸中的首地址，即判断是否同一个字符串对象 String特点：不可变性 String str=“hello,World!” // String subStr=str.subString(6); // String subStr=str.subString(6,str.length()-1); String subStr=str.subString(5,6); System.out.println(“截取的子字符串”,subStr); int index=str.indexOf(“;”); System.out.println(“,的索引值：”+index); int index1=str.lastIndexOf(“1”); System.out.println(“最后一个1的下标：”+index1); char ch=str.chatAt(6); System.out.println(“获取某个位置的字符”+ch); str=str.replace(“1”,”好”);6 System.out.println(“替换后的字符串：”+str); //str=str.trim();//去掉前后空格 str=str.replace(“”,””);//去掉所有空格 System.out.println(“字符串的长度”+str.length()); temps=input.split(“”);//分隔字符串，返回字符串数组 JDK提供基本包 1.java.lang:虚拟机自动引入 2.java.util:提供一些实用类 3.java.io:输入，输出 使用MyEclipse创建包的两种方法 1.分别创建包和累 2.创建类的过程中创建类所在的包 包命名规范 包名由小写字母组成，不能以原点开头或结尾 package mypackage 包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名 package net.javagroup. mypackage 包名后续部分依不同机构内部的规范不同而不同
package net.javagroup. research.powerproject
powerproject：部门名，项目名 使用包的注意事项 一.一个类同时引用了两个来自不同包的同名类 必须通过完整类名来区分 二.每个包都是独立的，顶层包不会包含子包的类 三.package和import的顺序是固定的 package必须位于第一行（忽略注释行） 只允许有一个package语句 其次是import 接着是类的声明 包的作用 1.允许类组成较小的单元（类似文件夹），易于找到和使用相应的文件2.防止命名冲突区分名字相同的累3.有助于实施访问权限控制 static修饰符 1.成员变量 静态变量，可以直接通过类名访问 2.成员方法 静态方法，可以直接通过类名访问 3.代码块 静态代码块，当java虚拟机加载类时，就会执行代码块
static变量与实例变量 类的成员变量包括 1.类变量（静态变量） 被static修饰的变量 在内存中只有一个拷贝 类内部，可以在任何方法内直接访问静态变量 其他类中，可以直接通过类名访问 实例变量 没有被static修饰的变量 每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响 static变量的作用 1.能被类的所有实例共享，可作为实例之间进行交流的共享数据 2.如果类的所有实例都包含一个相同的常量属性，可把这个属性定义为静态常量类型，从而节省内存空间 静态方法：可以直接通过类名访问 1.静态方法中不能使用this和super 2.不能直接访问所属类的实例变量和实例方法 3.可直接访问类的静态变量和静态方法 实例方法：通过实例访问 可直接访问所属类的静态变量、静态方法、实例变量和实例方法 静态方法必须被实现（main方法是最常用的静态方法） JVM加载类时，加载静态代码块 如果有多个静态块，按顺序加载 每个静态代码块只会执行一次 子类和父类是is-a关系 java是单根继承，即一个类只能有一个父类
四.访问修饰符总结 访问修饰符 本类 同包 子类 其他 private ✅ 红色方形 默认（friend） ✅ ✅ 蓝色三角形 protected ✅ ✅ ✅ 黄色菱形 public ✅ ✅ ✅ ✅ 绿色原点
抽象方法的特性 （1）.必须定义在抽象类中，但是抽象类中可以没有抽象方法 （2）.抽象方法没有方法体 （3）.父类的抽象方法子类必须实现，不想实现的唯一情况：子类也是抽象类
子类继承父类的什么？ 继承 public 和 protected 修饰的属性和方法，不管子类和父类是否在同一个包里 继承默认权限修饰符修饰的属性和方法，但子类和父类必须在同一 个包里
方法重写：在不同的类中，方法名相同，参数列表相同，返回值相同或是其子类，访问修饰符不能严于父类 1.父类的静态方法不能被子类覆盖为非静态方法，父类的非静态方法不能被子类覆盖为静态方法 2.子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法（静态方法中无法使用super） 3.父类的私有方法不能被子类覆盖 4.不能抛出比父类方法更多的异常
二.子类不能继承父类的那些东西 1.父类的private成员不能被继承 2.子类和父类不在同包下，使用默认访问权限的成员不能被继承 3.父类的构造方法不能被继承
Object 类 Object 类被子类经常重写的方法 说明 方法 toString () 返回当前对象本身的有关信息，按字符串对象返回 equals ()比较两个对象是否是同一个对象，是则返回 true hashCode () 返回该对象的哈希代码值 getClass ()获取当前对象所属的类信息，返回 Class 对象
区别 this super 访问属性 访问本类属性 访问父类中的属性 如果没有则从父类找 访问本类访问 访问方法 如果没有则从父类找 访问父类中的方法 调用本类构造 访问构造 放在构造方法首行 调用父类构造，放在子类构造方法首行
继承条件下构造方法的调用规则 1.子类构造方法没有通过 super 显式调用父类的有参构造方法，也没通过 this 显式调用自身其他构造方法 系统默认调用父类的无参构造方法 2.子类构造方法通过 super 显式调用父类的有参构造方法 执行父类相应构造方法，而不执行父类无参构造方法 3.子类构造方法通过 this 显式调用自身的其他构造方法，在相应构造方法中应用以上两条规则
父类 对象名=new 子类（）//这种方式叫做向上转型（自动类型转换）
接口
抽象类利于代码复用 接口利于维护。
异常
异常处理的五个关键字
try,catch,finally,throw,throws
try,catch
,finally
try{
//业务代码
//...
// 出现异常，去执行catch
}
catch(exception ex){ //exception,所有异常类型的父类
ex.printStackTrace();//输出异常的堆栈信息
ex.getMessage();//返回异常描述的字符串
}
finally{
//无论程序是否出现异常，都会执行
}
组合：try-catch/try-finally/try-catch-finally
1.异常处理中出现return的执行顺序
1.直接return 2.return 1；（返回一个数据类型）
try{ try{
return 1；
return； }
}catch{ catch{
return 1；
return； }
}finally{ finally{
return 1； }
}
| 1.直接return | return 1；（返回一个数据类型） |
|---|---|
| 先执行try、catch中return之前的语句，接着执行finally中的语句，返回去执行try、catch中的return | 依次执行，先执行try/catch中的代码，接着执行finally里面的代码，finally中的return覆盖掉try/catch中的return |
2.finally不被执行的唯一情况
System.exit(1)
3.多重catch
try{
//业务代码
}
} catch (InputMismatchException e) {
System.err.println("请输入正确的数字");
}
catch (Exception e) {
System.out.println(e.getMessage());
}
finally{
//无论程序是否出现异常，都会执行
}
注意事项：
多重catch块的排列顺序必须是从子类到父类，如果父类放到前面，，则后面的异常不被执行
throw，throws
-
throw用于抛出异常（throw new exception（“ ”））；位于方法体内部，可作为单独语句使用，只能抛出一个异常对象
-
throws用于声明异常，必须跟在方法参数列表的后面，不可单独使用，后面+异常类，可用多个
-
使用throw抛出异常时，必须显示处理异常/接着往上一级抛出异常
异常的分类
1.常见的异常类型
| 异常 | 说明 |
|---|---|
| Exception | 异常层次结构的根类 |
| arithmeticexception | 算数异常 |
| arrayindexoutofboundsexception | 数组下标越界 |
| nullpointerexception | 空指针异常 |
| classnotfoundexception | 不能加载所需要的类 |
| illegalargumentexception | 方法参数异常 |
| InputMismatchExcepton | 数据类型与输入不匹配 |
| ClassCastException | 对象强制类型转换出错 |
| NumberFormatException | 数字格式转换异常 |
2.异常分类
-
基类为Throwable，分为Error和Exception，
-
Error表示仅靠程序自身无法恢复的严重错误，灾难性错误
-
Exception分为RuntimeException和IOException
-
RuntimeException运行时异常，不要求程序必须做出处理，也称unchecked
-
checked异常（非运行时异常），程序必须捕捉病处理异常
开源日志工具 log4j
-
下载log4j的JAR文件，网址Apache log4j 1；；.2 -
-
日志的使用：
导包：Eclipse--选中src，点击Project--properties--Java Build Path--Libraries--Add External JARs.......
创建log4j.properties文件：用来配置日志信息，右击src--选择new--file创建
编写配置文件信息；
##设置Logger输出级别和输出目的地
log4j.rootLogger=debug, stdout,logfile
##把日志信息输出到控制台
log4j.appender.stdout=org.apache.log4j.ConsoleAppender log4j.appender.stdout.Target=System.err log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout
##把日志信息输出到文件：jbit.log
log4j.appender.logfile=org.apache.log4j.FileAppender log4j.appender.logfile.File=jbit.log log4j.appender.logfile.layout=org.apache.log4j.PatternLayout log4j.appender.logfile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss}%l %F %p %m%n
1.输出级别
debug<info<warn<error<fatal
fatal:出现严重错误将会导致应用程序的退出
error：出现错误，但不影响程序继续运行
warn：表示会出现潜在错误
设置输出级别时，程序只输出级别相同或者高于他的信息
空指针异常
String name=null; //name为空
System.out.println(name.equals("accrp"));
强制中断 System.exit(1);
集合框架与泛型
Collection接口存储一组不唯一,无序的对象. List接口存储一组不唯一,有序的(插入顺序)的对象. Set接口存储一组唯一,无序的对象. Map接口存储一组键值对象,提供key到value的映射.
List接口的实现类
ArrayList实现长度可变的数组，内存中分配连续的空间，遍历元素和随机访问元素的时效率比较高.
arrayList.clear(); //清空集合 数据初始化时使用 arrayList.remove(0); //删除 int index=arrayList.indexOf(); //索引值 arrayList.set(0,newTitle3); //更新
LinkedList采用链表存储方式，插入、删除元素时效率比较高.
void addFirst(Object 0); //在列表的首部添加元素 void addLast(Object 0); //在元素末尾添加元素 Object getFirst(); //返回列表中的第一个元素 Object getLast(); //返回列表中的最后一个元素 Object removeFirst(); //删除并返回列表中的第一个元素 Object removeLast(); //删除并返回列表中的最后一个元素
Set接口的实现类
HashSet 是Set接口中最常用的接口类
Iterator 方法: boolean hasNext(); //判断是否存在另一个可访问的元素 Object next(); //返回要访问的下一个元素
//遍历set集合 通过迭代器Iterator实现遍历
NewTitle newTitle1=new NewTitle("001","1旅游","张1");
NewTitle newTitle2=new NewTitle("002","2旅游","张2")
NewTitle newTitle3=new NewTitle("003","3旅游","张3");
//创建集合
Set set=new HashSet();
set.add(newTitle1);
set.add(newTitle2);
set.add(newTitle3);
Iterator iterator=set.iterator(); //创建迭代器]
while (iterator.hasNext()){
Object obj=iterator.next();
NewTitle newTitle=(NewTitle)obj;
newTitle.showInfo();
}
System.out.println();
for (Object obj:set) {
NewTitle newTitle=(NewTitle)obj
newTitle.showInfo();
}
TreeSet
Map接口的实现类
HashMap
四种遍历方法
Map map=new HashMap();
map.put("cn","china");
map.put("jp","Japen");
map.put("en","England");
map.put("usa","American");
map.put("fr","france");
map.put("fr","france111");
System.out.println("map的长度:"+map.size());
System.out.println("key的集合:"+map.keySet());
System.out.println("值的集合:"+ map.values());
System.out.println("键值对集合:"+map);
//通过键删除对应的键值
if (map.containsKey("jp")){
map.remove("jp");
}
//迭代器 1.keySet
// Iterator iterator=map.keySet().iterator();
// while (iterator.hasNext()){
// String key= (String) iterator.next();
// String value= (String) map.get(key);
// System.out.println(key+"======"+value);
// }
//迭代器 2.entrySet
Iterator iterator1=map.entrySet().iterator();
while (iterator1.hasNext()){
Object obj=iterator1.next();
Map.Entry<String,String>entry=(Map.Entry<String,String>)obj;
String key=entry.getKey();
String value=entry.getValue();
System.out.println(key+"======="+value);
}
//方法一 增强for遍历key的集合 set
Set keys=map.keySet(); //获取Map中所有的key
for (Object obj:keys) {
String key=(String) obj; //获取Map中的每一个key
String value=(String) map.get(key); //根据Map中的每个key去获取先对应的value
System.out.println(key+"======="+value);
}
Set set=map.entrySet(); //获取Map中的键值对
//遍历键值对的集合,把每个键值对(obj)--map.Entry(键值对的类型)拿出来
for (Object obj:set) {
Map.Entry me= (Map.Entry) obj;
String key= (String) me.getKey(); //获取键值对中的键
String value= (String) me.getValue(); //获取键值对中的值
System.out.println(key+"======="+value);
}
}
泛型的好处 安全 稳定
Collections排序
可以对集合进行排序、查找、和替换操作
Compartor
return this.stuNo-o.stuNo; //升序 return o.stuNo-this.stuNo; //降序
枚举(enum)
由一组固定的常量组成的类型
枚举优点:
类型安全 易于输入 代码清晰
包装类
把基本数据类型转换为对象
作用:
提供了一系列实用方法 集合不允许存放基本数据类型数据,存放数字时,要用包装类型
构造方法
所有包装类都可将与之对应的基本数据类型作为参数,来构造它们的实例.
//XXXValue():包装类转换成基本类型.
Integer num5=new Integer(67);
int num6=num5.intValue();
System.out.println("num6="+num6);
//toString():以字符串形式返回包装对象表示的基本数据类型(基本类型->字符串) 第一种 String str1=Double.toString(34.36); 第二种 方便 String ste2=34.56+"";
//parseXXX(): 把字符串转换为相应的基本数据类型数据(Character除外)(字符串->基本类型)
int num=Integer.parseInt("36");
boolean bool=Boolean.parseBoolean("false");
valueOf()
//所有包装类(基本类型->包装类) Integer intValue=Integer.valueOf(21);
除Chara类除外,其他包装类都有如下方法(字符串->包装类)
装箱拆箱
装箱:基本类型转换为包装类的对象. 拆箱:包装类对象转换为基本类型的值.
Integer intObject=5; int intValue=intObject;
包装类的特点
jdk1.5后允许基本数据类型和包装类型进行混合数学运算. 包装类并不是用来取代基本数据类型的.
Math类
math.abs(-3.5) //3.5 math.max(2.5,90.5) //返回90.5
int max=Math.max(34,100);
System.out.println("最大值:"+max);
int min=Math.min(78,89);
System.out.println("最小值:"+min);
double num=Math.pow(3,4); //求幂次方
System.out.println("幂次方:"+num);
double radom=Math.random();
System.out.println("随机数:"+radom);
int num2=Math.abs(-89); //绝对值
System.out.println("绝对值:"+num2);
//ceil() 方法可对一个数进行上舍入，返回值大于或等于给定的参数，类型为双精度浮点型
double ceiling=Math.ceil(34.5);
System.out.println(ceiling);
//floor() 方法可对一个数进行下舍入，返回给定参数最大的整数，该整数小于或等给定的参数。
double floor=Math.floor(34.5);
System.out.println(floor);
double num3=Math.sqrt(9); //平方根
System.out.println("开方:"+num3);
double round=Math.round(34.567); //四舍五入
System.out.println("四舍五入:"+round);
生成随机数
Random random=new Random();
for (int i = 0; i < 10; i++) {
int nums=random.nextInt(10);
System.out.println(nums);
}
//随机生成5位数的会员号
Random random=new Random();
for (int i = 0; i <20; i++) {
int nums=random.nextInt(9000)+1000;
System.out.println(nums);
}
时间
如何获取当前日期
java.util.Date类: 表示日期和时间
格式化日期:
java.text.SimpleDateFormat类
Date d1=new Date(); //获取当前日期
SimpleDateFormat simpleDAteFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//格式化
String str=simpleDAteFormat.format(d1);
System.out.println(str);
Galendar类
抽象类,java.util.Galendar
用于获取日期和时间数据的特定部分 提供一些方法和静态字段来操作日历
Calendar calendar=Calendar.getInstance();
int year=calendar.get(Calendar.YEAR); //年
int month=calendar.get(Calendar.MONTH)+1; //月
int week=calendar.get(Calendar.DAY_OF_WEEK)-1; //周s
System.out.println(year+"年"+month+"月"+day+"日"+"今天是周"+week);
calendar.set(2021,04,06); //定义
int weekyear=calendar.get(Calendar.WEEK_OF_YEAR); //今年的第"+week+"周
System.out.println("今年的第"+weekyear+"周");
1742
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
