第四章重载&访问修饰符&静态&常用类 ① 笔记

小丫头爱打盹

已于 2022-06-29 14:54:40 修改

阅读量330

点赞数

分类专栏： # Java 文章标签： java 前端大数据

于 2022-06-29 14:42:57 首次发布

本文链接：https://blog.csdn.net/Liu_wen_wen/article/details/125519739

版权

Java 专栏收录该内容

25 篇文章 2 订阅

订阅专栏

1.内容回顾

 对象的概念
可以从属性和行为两个方面来进行描述，具有具体形象的事物，成为对象。
 类的使用
使用类可以创建对象，使用对象可以进行程序处理。
 构造方法
在类中定义的用于创建类的对象的方法。
1)构造方法的方法名与类名相同
2)构造方法不能有返回值，也不能写void
3)构造方法可以通过new关键字来调用
 普通方法
能够完成特定功能的方法就是普通方法/成员方法
 方法要定义在类中。多个方法在类中定义的次序没有要求。
 方法之间可以相互调用。但是不能形成循环调用，否则会内存溢出
 方法定义后需要通过对象调用才能执行。
 如果方法是有参数的，则调用方法时必须参数类型和次序传参
 如果方法定义了返回值的类型，则方法执行后必须按照返回值的类型返回数据。如果方法代码块中存在分支结构需要确保最终方法执行完成的时候是有返回值的。
如果方法没有返回值（即返回值类型是void），测试方法可以不写return。也可以写return，但是return后面不能跟数据，测试return的作用是终止方法执行。

2.本章重点

2.1方法重载
2.2包和访问修饰符
2.3static关键字
2.4StringBuilder和StringBuffer
2.5日期及格式化

3.具体内容

3.1.方法重载

为什么需要方法重载？
在一个类中可以有很多的方法，并且每一个方法都有自己的功能，但是方法太多，对开发者不友好，名字太多不好记，所以使用方法重载，控制每一个方法中传入的参数，并且方法的名字都一样，java,会自动的根据传入参数的不同，调用参数相对应的方法。此时开发者不需要再记各种方法的名字了。非常nice !
什么是方法重载？

//方法重载:方法名相同，参数不同，构成了方法重载.
//好处: 方便调用
//特征:方法重载只与方法名和参数有关，方法名相同，参数不同(个数，类型，次序)
//与参数名，返回值，访问修饰符无关。

// 方法重载:
在一个类中，方法名相同，参数不同（个数不同，类型不同，次序不同），构成方法重载
方法重载与访问修饰符，返回值类型，方法参数名没有关系

// 作用: 方便使用者调用方法

public class Calc {
// 加法操作
	public void add(int n1,int n2){
		int res = n1+n2;
		System.out.println(res);
	}
	public void add(String s1,String s2){
		String res = s1+s2;
		System.out.println(res);
	}
	public void add(double d1,double d2){
		System.out.println(d1+d2);
	}
	public void add(int n1,int n2,int n3){
		System.out.println(n1+n2+n3);
	}
	public void add(int n1,int n2,double d1,double d2){
		System.out.println(n1+n2+d1+d2);
	}
	public void add(double d1,double d2,int n1,int n2){
		System.out.println(n1+n2+d1+d2);
	}
}

public class Test2 {
	public static void main(String[] args) {
		Calc c = new Calc();
		c.add(100,200);
		c.add("aaa","bbb");
		c.add(1.0,2.0);
		c.add(1,2,3.0,4.0);
	}
}

经典面试题：

在一个类中可以有很多个相同名字的方法，并且这些方法中参数列表不同(参数个数不同，顺序不同，类型不同)，这就是方法重载。
特点：

函数/方法名相同
参数列表不同（参数个数不同，顺序不同，参数类型不同）。
如果方法名相同，参数列表也相同，此时虚拟机就懵逼了，不能分辨到底调用哪一个方法。
注意：方法重载不考虑返回值，不考虑参数名，不考虑访问修饰符。

3.2.包和访问修饰符

包
包的作用，用于分门别类，不同功能的类放在不同的包中用于区分。
1）为什么需要包？
a：没有包的话，类多的时候不好找，所以包的作用在于管理类。包在磁盘体现上就是文件
夹。
b：不同包下的类可以重名（同一目录类不能重名）
c：可以通过包做一些限定
2）包的定义语句：package 包名；
3）跨包请求的时候需要导入包：import 包名.类名；导入指定类import 包名.*;
//属于 java.lang 包下边得内容每一个类都会自动的引入java.lang 包

System.out.println();
String int boolean …

package com.ali;
/**
 * @author: XYT
 * @create-date: 2022/6/28 11:20
 */
//人脸识别功能
public class FaceRec {
public void use(){
System.out.println("使用阿里的人脸识别模块");
}
}

package com.tecent;
/**
 * @author: XYT
 * @create-date: 2022/6/28 11:21
 */
public class FaceRec {
public void use(){
System.out.println("使用tencent的人脸识别");
}
}

package com.qy151.test3;
//import com.ali.FaceRec;
//import com.tecent.FaceRec;
/**
 * @author: XYT
 * @create-date: 2022/6/28 11:22
 */
public class MyTest1 {
public static void main(String[] args) {
//FaceRec faceRec = new FaceRec();
//faceRec.use();
//通过报名来限定类
com.ali.FaceRec fr1 = new com.ali.FaceRec();
fr1.use();
com.tecent.FaceRec fr2 = new com.tecent.FaceRec();
fr2.use();
}
}

1. 权限/访问范围修饰符

使用修饰符定义了类和类中的字段或方法时。就可以限定该类或类中字段或方法能被哪些范围的类或那些方法来使用。
 类的修饰符(两种) ： public 默认 (不写的时候就是默认)
public:所有包中都可以访问默认:同包下的类可以访问，其他包的类不能访问
 类中属性/方法的修饰符(四种): public(公有) protected(受保护) 默认 private(私有)
public 公共的：主要修饰成员变量和方法
作用：权限的设置，保护属性不被外界侵犯。

在这里插入图片描述
public 公共的公共wc。一个项目中都可以。
protected 受保护的小区里的wc。
默认：default friendly
private 私有的自己家的wc

// 访问修饰符:
// 1.针对类的 public , 默认
// 1.针对属性和方法的 public,protected,默认,private
// public: 在任意包任意类中可以访问到
// private: 只在当前类中能被访问，其它包其他类都不能访问
// 默认(不写访问修饰符): 在同包的类中可以访问，在其它包的类中不能访问

3.3.static关键词

static：静态的
用来修饰属性（成员变量），则该属性就成为类属性(不依赖于某个对象而存在)，所有该类的实例对象都共用这一个属性，任何一个实例改变了静态属性值，大家看到的都是修改过的值。
在内存中static属性是所有类实例共有的内存地址。static来修饰方法，则该方法就成为静态方法，可以直接通过类名访问，一般在工具类中定义工具方法。
静态变量和实例变量的区别:
1.实例变量，依赖于实例对象而存在。访问实例变量的时候，必须通过实例对象来访问
2.实例变量，在内存中可以有多份（内存中创建了多少实例对象，就有多少实例变量）
每个实例对象的实例变量互不影响
3.静态变量，不依赖于对象而存在。直接与类关联，可以通过类名来访问
4.静态变量，在内存中只有一份，被所有实例对象共享。

static的使用场景:

 static修饰的变量叫静态变量
 static修饰的方法叫静态方法
 static修饰的代码块叫静态代码块
在这里插入图片描述

public class MyCls {
//实例变量x
int x;
//静态变量num
static int num;
{
System.out.println("这是实例代码块");
}
static {
System.out.println("这是静态代码块");
}
public MyCls(){
System.out.println("这是构造方法");
}
//实例方法/普通方法
public void test(){
//实例方法可以访问实例变量，也可以访问其他实例方法
System.out.println(this.x);
//实例方法可以访问静态变量
System.out.println(MyCls.num);
//实例方法可以访问静态方法
aaa();
}
public static void bbb(){
}
//静态方法
public static void aaa(){
//静态方法不能访问实例属性/变量
//System.out.println(x);
//静态方法可以访问静态属性/变量,也可以访问其他静态方法
System.out.println(num);
//静态方法不能访问实例方法
//test();
}
}

static的特点:
所有的静态（静态变量和静态方法）都属于类（全局）

 静态属性和静态方法可以直接通过类名.静态属性类名.静态方法() 来使用，这是推荐的方式。当然也可以通过实例对象来访问静态属性和静态方法，但是这种做法不推荐
 静态方法中，只能访问静态属性和其它静态方法。不能访问实例属性和实例方法
 实例方法中，可以访问静态属性和静态方法，也可以方法实例属性和实例方法
 静态代码块，在类被加载时自动调用。

public class MyCls {
//实例代码块
{
System.out.println("普通代码块");
}
// 静态代码块
static {
System.out.println("静态代码块");
}
// 构造方法
public MyCls(){
System.out.println("构造方法");
}
}
public class Saler {
String name;
// 内存中只有一份
static int ticket = 10;
// 有参构造
public Saler(String name){
this.name=name;
}
public void sold(){
// 票数减去1
Saler.ticket--;
if(Saler.ticket<0){
System.out.println("票已经卖完了");
return;
}
System.out.println(this.name+"卖票一张,还剩"+Saler.ticket+"张");
}
}

测试类：

public class Test {
public static void main(String[] args) {
Saler s1 = new Saler("孙悟空");
Saler s2= new Saler("白骨精");
s1.sold();
s2.sold();
s1.sold();
s2.sold();
s1.sold();
s2.sold();
s1.sold();
s2.sold();
s1.sold();
s2.sold();
}
}

3.4.String

基本数据类型(四类八种) ：不属于Object类型的继承体系之下
引用数据类型(字符串，数组，自定义类型) ：属于对象类型 Object类型的继承体系之下。
String 字符串引用数据类型 Object
在这里插入图片描述

在这里插入图片描述

什么是String
字符串 , 引用类型。（基本类型的变量存储的是数据，引用类型的变量存储的是数据的地址）
字符串对象。
String的特点：
 字符串不可变
 每一个字符串都是String类的实例对象
 正是因为字符串是不可变的，所以字符串是共享的。
 字符串的效果上相当于一个char[] 数组，但是它的底层原理是byte[] 字节数组。
创建字符串的2种常用方法
 最常用的直接创建 String str = “ABC”;
注意：直接使用双引号的就是字符串对象。虽然没有new
 通过构造方法创建
String str = new String(“abc”);
字符串常用方法
在这里插入图片描述
基本操作：

String a=new String("abcd");//创建了两个String实例
String b="abc";//常用的创建String方法
int c=9;
String d=String.valueOf(c);//""+c;
String id="454150199608121256";
System.out.println(id.subString(6, 10)+"-"+id.substring(10,12)+"-"+id.substring(12,14))

替换中间的间隔符

String str="System-out-print";
System.out.println(str.replace("-",""));

输出结果是：Systemoutprint
在这里插入图片描述
要学会看源码
ctrl+鼠标左键点击“关键字”

在这里插入图片描述

小结:

栈中存变量，new的对象存在堆中。常量保存在常量池中。
String str1 = “abc”; 先去常量池中找”abc“ 是否存在，如果存在直接引用，不存在，就创建。
String str2 = “abc”;先去常量池中找”abc“ 是否存在，如果存在直接引用，不存在，就创建。

== ：用法

1. 如果是基本数据类型：== 比较值(变量中的值)。
2. 如果是引用数据类型：== 比较变量中存储的数据的地址。如果要比较内容用equals方法

面试题：

String str = “abc”;
问，这句代码创建了几个对象？

**答**：0个或1个。如果常量池中有"abc"了就是0个。如果之前没有就是1个

在这里插入图片描述

String str = new String(“abc”);
问，这句代码创建了几个对象？

**答** ：1个或2个。只要new，就会创建一个对象。另外看"abc"在常量池中是否存在

3.5.StringBuilder和StringBuffer

在java中字符串就是常量。就算对一个字符串进行操作，原来的字符串还是不会改变，只不过又生成了新的字符串。
我们对字符串做的任何操作，都不会改变原有字符串，但是会创建新的字符串对象。

String str1 = "abc";
str1 = "123";
System.out.println(str1);
此时输出str1值发生了改变，跟上边说的字符串不可变相违背。其实并没有，因为str1中保存的是

在这里插入图片描述

问题：
当拼接字符串操作时，因为字符串是不可变的，所以当我们拼接字符串时，每拼一次就会在常量池中生成一个新的字符串，开辟一块新的内存空间，如果拼接一亿次，就会开辟很多内存空间，严重浪费(浪费时间，浪费内存空间)。
在这里插入图片描述

如何解决？
StringBuilder和StringBuffer都可以用于字符串拼接的场景，提升空间利用率。
StringBuilder线程不安全，性能高。StringBuffer线程安全，性能低。
StringBuilder 是一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffer 要快。
在这里插入图片描述

String a="abcde";
String b="defg";
String c=a+b;
StringBuilder sb=new StringBuilder("abc");
StringBuilder sb1=sb.append(b);
sb1.insert(3, "1234");
System.out.println(sb1);
System.out.println(sb1.reverse());
//sb.append(b).insert(3, "6789").reverse();

//StringBuilder:专门用于字符串的拼接，修改操作，提升性能
StringBuilder stringBuilder = new StringBuilder("aaa");
stringBuilder.append("xxx"); //拼接字符串
stringBuilder.append("123");
System.out.println(stringBuilder);
stringBuilder.reverse(); //反转字符串
System.out.println(stringBuilder);
stringBuilder.insert(0,"yyy"); //在0的位置插入字符串
System.out.println(stringBuilder);
//StringBuilder 和 String 是不同类型的对象，要用toString()转换
String s = stringBuilder.toString();
//StringBuffer: 门用于字符串的拼接，修改操作，提升性能。线程安全。
StringBuffer strb = new StringBuffer();
strb.append("xxxx");
strb.append("1111");
System.out.println(strb);

求1~10000以内的回文数
121,1221

for(int i=1;i<10000;i++) {
StringBuilder sb = new StringBuilder("");
sb.append(i);//将数字拼接字符串
String old = sb.toString();//获取StringBuilder中的字符串原值
if (old.equals(sb.reverse().toString())) {//将原值和反转后的字符串原
System.out.print(old+"\t");
}
}

3.6.日期及格式化

日期格式字符串
y ：代表年
M ：代表月
d：代表日
E：代表星期
H ：代表24进制的小时
h ：代表12进制的小时
m：代表分钟
s ：代表秒
S ：代表毫秒
需要import java.util.Date;

//获取一个日期对象
Date date = new Date();
System.out.println(date);

SimpleDateFormat类格式化日期。

功能：格式化和解析日期

将Date类型的日期格式化成我们需要的日期类型一般是字符串类型
将字符串类的日期再转回来。

上边代码得到的date格式不是我们常用的格式，但是我们可以把它转化成我们常用的格式，通过SimpleDateFormat类中的 format(Date date) 将date型转换成特定格式的字符串。
在这里插入图片描述

//转化称我们能看懂的格式 new SimpleDateFormat("yyyy-MM-dd W w EEE hh:mm:ss");
// 参数 就是你想要的日期 格式 2020-10-16 16:36 2020/10/16 16:36
//yyyy---> 年
//MM---> 月
//dd --> 日
//HH --> 24小时制
//hh--> 12小时制
//mm --> 分钟
//ss -->秒
//EEE -->星期
//W --> 一月中的第几周
//w--> 一年中的第几周
SimpleDateFormat sm1 = new SimpleDateFormat("yyyy/MM/dd W w EEE hh:m
String ss = sm1.format(date);
System.out.println(ss);

也可以通过SimpleDateFormat类将一个字符串格式的日期，转换成Date类型。使用
parse(String str) 将字符串str转换成特定格式的date型如下代码。

public static void main(String[] args) throws ParseException {
	Date date = new Date();//获取一个国际化的日期格式
	System.out.println(date);//Fri Nov 13 11:26:04 CST 2020
	System.out.println(date.getTime());//获取毫秒数
	System.out.println(date.getHours());
	//使用SimpleDateFormat 类 来堆日期进行格式化
	//将国际化的日期格式转化为中国通用格式 Date--->String
	// 1.需要一个格式化的日期对象
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd E HH:mm:ss")
	//2.调用日期对象的format方法，进行转化。
	String s = sdf.format(date);
	System.out.println(s);
	//将中国通用格式String---》Date类型
	String str = "2020-11-13 星期五 11:40:24";
	SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd E HH:mm:ss"
	Date parse = sdf1.parse(str);
	System.out.println(parse);
}

输出当前系统时间为汉语格式

Date d=new Date();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss");
System.out.println(d);
System.out.println(sdf.format(d));

jdk1.8之后的新增日期时间相关类
在这里插入图片描述

在这里插入图片描述

public static void main(String[] args) {
LocalDate now = LocalDate.now();
System.out.println(now);
LocalTime now1 = LocalTime.now();
System.out.println(now1);
LocalDateTime now2 = LocalDateTime.now();
System.out.println(now2);


 //使用DateTimeFormatter 将日期转化成字符串类型
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd");

String ss = now.format(dateTimeFormatter);
System.out.println(ss);


//使用DateTimeFormatter 将字符串转化成Date类型
String str = "2020/10/16";
//创建一个格式化日期类，用来解析字符串日期

DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy/MM/dd");

LocalDate date = LocalDate.parse(str, dateTimeFormatter1);
System.out.println(date);

DateTimeFormatter格式化日期类

方法：
ofPattern(“日期格式”); 创建特定格式的格式化日期对象
Duraction类 表示：时间的区间，用来度量秒和纳秒之间的时间值
Period类 表示：一段时间的区间，用来度量年月日和几天之间的时间值
Duration.between()；
Period.between();
计算时间差值
计算时间的差值：Duration.between()

public static void main(String[] args) throws ParseException {
LocalDateTime ldt=LocalDateTime.now();
LocalDateTime paldt=LocalDateTime.parse("1999-10-16T17:10:16.355"
Duration dt=Duration.between(paldt,ldt);
System.out.println(dt.toDays());//间隔的天数
System.out.println(dt.toHours());//小时
System.out.println(dt.toMinutes());//分钟
System.out.println(dt.getSeconds());//毫秒
}

public static void main(String[] args) {
String s1 = "2020-11-20";
String s2 = "2022-10-11";
LocalDate ld1 = LocalDate.parse(s1);
LocalDate ld2 = LocalDate.parse(s2);
//Duration d1 = Duration.between(ld1,ld2);
//Period p = Period.between(ld1,ld2);
// ChronoUnit类可用于在单个时间单位内测量一段时间，例如天数或秒。
long days = ChronoUnit.DAYS.between(ld1,ld2);
System.out.println(days);
}

实例: 身份证中的年月日转为日期对象

public static void main(String[] args) throws ParseException {
String id="415254199811250159";
SimpleDateFormat sd=new SimpleDateFormat("yyyyMMdd");
System.out.println(sd.parse(id.substring(6,14)));
}

4.本章总结

 方法重载
 包和访问修饰符
 方法重载
 static关键字
 StringBuilder和StringBuffer
 日期及格式化

5.课后作业

static的使用：售票员卖票
给一个CSS样式属性字符串，要求输出驼峰格式的名称(5分钟)；
给一个身份证号码，要求输出这个人的生日（格式为：yyyy年MM月dd日）,并计算这个人的
年龄(使用两种以上方式完成)。
熟练使用jdk API 去把String的方法测试一遍。
将样式表中的属性转换成驼峰命名的属性名-1

String str="border-right-color";
String[] sss=str.split("-");
String result="";
result+=sss[0];
for(int i=1;i<sss.length;i++) {
	String f=sss[i];
	String first=f.substring(0, 1);
	String end=f.substring(1);
	String up=first.toUpperCase();
	System.out.println(up);
	System.out.println(end);
	System.out.println(up+end);
	result+=(up+end);
}
System.out.println(result);

统计一个字符串中重复出现的内容的次数和位置.
String s = “新年好呀，新年好呀，祝福大家新年好”
封装一个方法，实现将首字母转大写的操作
“name”-> “Name” “age” -> “Age”
实现将border-top-left-radius 转为 borderTopLeftRadius格式。要调用自己封装的方法
仿照js的要求，完成邮箱验证
求两个日期的差：输入两个字符串，求差

// A code block
var foo = 'bar';

小丫头爱打盹

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第四章重载&访问修饰符&静态&常用类 ① 笔记

方法重载包和访问修饰符权限/访问修饰符 static关键词 String StringBuilder StringBuffer 日期及格式化 SimpleDateFormat类格式化日期 DateTimeFormatter类格式化日期类
复制链接

扫一扫