一. 二维数组
-
定义
所谓的二维数组就是在数组中存放数组
外层数组中存储的是数组的引用
-
初始化
-
静态初始化
先指定数组中的内容, 长度由jvm自定判断
数据类型[ ][ ] 数组名 = new 数组类型[ ][ ]{ {元素,元素},{元素,元素}}
数据类型[ ][ ] 数组名 = { {元素,元素},{元素,元素}}
-
动态初始化
先指定数组的长度,jvm会给数组附上默认值
数据类型[ ][ ] 数组名 = new 数组类型[数组的长度 ][数组的长度 ]
-
-
演示
<pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="java" cid="n31" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Monaco, Consolas, "Andale Mono", "DejaVu Sans Mono", monospace; margin-top: 0px; margin-bottom: 20px; background: rgb(51, 51, 51); font-size: 0.9rem; display: block; break-inside: avoid; text-align: left; white-space: normal; position: relative !important; padding: 10px 10px 10px 30px; width: inherit;">public static void main(String[] args) {
int[][] arrs = {{2,3},{8,6},{7,5}};for (int i = 0; i < arrs.length; i++) {
//获取一个子数组, 变量子数组中的内容
for (int j = 0; j < arrs[i].length; j++) {
System.out.println(arrs[i][j]+" ");
}
System.out.println();
}
}</pre>
二. 权限修饰符
-
什么是权限修饰符
- 权限修饰符是为了确定类或者类成员的使用范围
-
java中权限修饰符
private 类中
默认(什么都不写) 类中 包下
protected 类中 包下 别的包的子类中(子父类调用)
public 类中 包下 别的包的子类中 其他包
-
演示
<pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="java" cid="n52" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Monaco, Consolas, "Andale Mono", "DejaVu Sans Mono", monospace; margin-top: 0px; margin-bottom: 20px; background: rgb(51, 51, 51); font-size: 0.9rem; display: block; break-inside: avoid; text-align: left; white-space: normal; position: relative !important; padding: 10px 10px 10px 30px; width: inherit;">public class RestrictDemo {
public void test(){
//public 权限本类中可以调用
method1();
//protected 权限在本类中可以调用
method2();
//默认 权限在本类中可以调用
method3();
//private 权限在本类中可以调用
method4();
}
public void method1(){
}
protected void method2(){
}
void method3(){
}
private void method4(){
}
}
</pre><pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="java" cid="n53" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Monaco, Consolas, "Andale Mono", "DejaVu Sans Mono", monospace; margin-top: 0px; margin-bottom: 20px; background: rgb(51, 51, 51); font-size: 0.9rem; display: block; break-inside: avoid; text-align: left; white-space: normal; position: relative !important; padding: 10px 10px 10px 30px; width: inherit;">public class Son extends RestrictDemo{
public void test(){
RestrictDemo demo = new RestrictDemo();
//public 权限在同一个包下的别的类中可以调用
demo.method1();//protected 权限在同一个包下的别的类中可以使用
demo.method2();//默认 权限在同一个包下的别的类中可以使用
demo.method3();//private 权限在同一个包下的别的类中不能使用
demo.method4();
// 即使是子类中也不能使用
method4();
}
}</pre><pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="java" cid="n54" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Monaco, Consolas, "Andale Mono", "DejaVu Sans Mono", monospace; margin-top: 0px; margin-bottom: 20px; background: rgb(51, 51, 51); font-size: 0.9rem; display: block; break-inside: avoid; text-align: left; white-space: normal; position: relative !important; padding: 10px 10px 10px 30px; width: inherit;">public class TestDemo extends RestrictDemo{
public void main(String[] args) {
RestrictDemo demo = new RestrictDemo();
//public 权限在不同包下别的类中可以调用
demo.method1();// protected 权限在不同包下别的类中不能调用
demo.method2();
// protected 权限在不同包下的子类中可以调用
method2();//默认 权限在不同包下别的类中不能调用
demo.method3();//private 权限在不同包下别的类中不能调用
demo.method4();}
}</pre>
三. JAVA中的包
-
定义
其实就是路径, 和电脑中的文件夹一个意思, java中的类名前面要加上包名才是完整的类的路径,记住,java主程序运行的地方就算作根路径
java程序想要从硬盘上找类文件,就会从当前位置找 包名+类名(最外层包所在的路径)
-
导入包
我们写程序的时候, 一般都是直接写类名, 编译器会默认给我们加上当前类的包名, 如果发现当前包下没有这个类的话,或者是这个类不是我们需要的,那么就需要我们手动添加包名
-
有两个方式
在类的前面写上包名
使用import关键字在类的上方导入
注意: 如果是用 * 号导入包的话, 当前类和导入的包下有相同的类, 默认使用本包下的
-
演示
<pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="java" cid="n81" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Monaco, Consolas, "Andale Mono", "DejaVu Sans Mono", monospace; margin-top: 0px; margin-bottom: 20px; background: rgb(51, 51, 51); font-size: 0.9rem; display: block; break-inside: avoid; text-align: left; white-space: normal; position: relative !important; padding: 10px 10px 10px 30px; width: inherit;">package com.qianfeng.packagedemo;
import com.qianfeng.packagedemo2.Demo2;
import com.qianfeng.packagedemo2.*;
public class TestDemo {
public static void main(String[] args) {
//没有写包名, 默认加上本类所在的包名
Demo demo = new Demo();//如果出现相同名称的类 就必须表明使用的类的包名
com.qianfeng.packagedemo2.Demo demo1 = new com.qianfeng.packagedemo2.Demo();//在类的上方使用import 关键字导入
Demo2 demo2 = new Demo2();
}
}</pre> -
注意:
程序中不能出现两个包名类名都相同的类
无法使用import关键字导入两个名称相同的类,因为编译器无法分清你到底要用哪个
[图片上传失败...(image-2fc62-1575503663502)]
-
测试题
有两个包, demo1 和 demo2 , 两个包下都有A类 B类 , 现在demo1包下A类中调用B类,推测执行的是哪个包下的B类?
<pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="java" cid="n95" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Monaco, Consolas, "Andale Mono", "DejaVu Sans Mono", monospace; margin-top: 0px; margin-bottom: 20px; background: rgb(51, 51, 51); font-size: 0.9rem; display: block; break-inside: avoid; text-align: left; white-space: normal; position: relative !important; padding: 10px 10px 10px 30px; width: inherit;">package demo1;
import demo2.B;
public class A {
public void method(){
demo1.B b = new demo1.B();
}
}</pre>
四. Object 类
-
定义
所有类的基类/根类
所有的类都是直接或者间接继承Object类
-
常用方法
-
hashCode()
public int hashCode()
返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
不同对象的，hashCode()一般来说不会相同。但是，同一个对象的hashCode()值肯定相同。
-
toString()
public String toString()
返回该对象的字符串表示
默认的方法返回的数据一般对我们没有意义, 建议重写
JavaBean中一定要去重写, 别的类中重写的概率很低
<pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="java" cid="n128" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Monaco, Consolas, "Andale Mono", "DejaVu Sans Mono", monospace; margin-top: 0px; margin-bottom: 20px; background: rgb(51, 51, 51); font-size: 0.9rem; display: block; break-inside: avoid; text-align: left; white-space: normal; position: relative !important; padding: 10px 10px 10px 30px; width: inherit;">public class Demo {
private String name;
private int age;
public Demo(){}
public Demo(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "TestDemo [name=" + name + ", age=" + age + "]";
}
}</pre> -
equals()
比较当前对象和指定对象内容是否"相等"
默认情况下比较的地址值是否相等
<pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="java" cid="n136" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Monaco, Consolas, "Andale Mono", "DejaVu Sans Mono", monospace; margin-top: 0px; margin-bottom: 20px; background: rgb(51, 51, 51); font-size: 0.9rem; display: block; break-inside: avoid; text-align: left; white-space: normal; position: relative !important; padding: 10px 10px 10px 30px; width: inherit;"> public static void main(String[] args) {
Demo demo1 = new Demo();
Demo demo2 = new Demo();boolean flg = demo1.equals(demo2);
System.out.println(flg); //结果为false
}</pre>- 在我们的日常逻辑中,比较地址值是否相等没有意义, 建议重写(重写之后比较的就是类中的成员变量的值是否一样)
<pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="java" cid="n140" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Monaco, Consolas, "Andale Mono", "DejaVu Sans Mono", monospace; margin-top: 0px; margin-bottom: 20px; background: rgb(51, 51, 51); font-size: 0.9rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; position: relative !important; padding: 10px 10px 10px 30px; width: inherit;">@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Demo other = (Demo) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
</pre> -
== 和equals()的区别
==是一个比较运算符号,既可以比较基本数据类型,也可以比较引用数据类型,基本数据类型比较的是值,引用数据类型比较的是地址值
equals方法是一个方法,只能比较引用数据类型,所有的对象都会继承Object类中的方法,如果没有重写Object类中的equals方法,equals方法和==号比较引用数据类型无区别,重写后的equals方法比较的是对象中的属性
equals()相等两个对象 hashCode()一定相同, equals不等的两个对象, hashCode()也有可能相同
建立在equals和hashCode同步重写的情况下
-
getClass()
public final Class getClass()
返回此对象的类, 可以借由字节码获取到类所有的基础结构属性
演示获取类名
<pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="java" cid="n161" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Monaco, Consolas, "Andale Mono", "DejaVu Sans Mono", monospace; margin-top: 0px; margin-bottom: 20px; background: rgb(51, 51, 51); font-size: 0.9rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; position: relative !important; padding: 10px 10px 10px 30px; width: inherit;">public static void main(String[] args) {
Demo demo = new Demo();String clazzName = demo.getClass().getName(); System.out.println(clazzName); //结果:com.qianfeng.common.Demo}
</pre>
-
-
测试题
推测 flg1 和 flg2 的结果
<pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="java" cid="n165" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Monaco, Consolas, "Andale Mono", "DejaVu Sans Mono", monospace; margin-top: 0px; margin-bottom: 20px; background: rgb(51, 51, 51); font-size: 0.9rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; position: relative !important; padding: 10px 10px 10px 30px; width: inherit;">public static void main(String[] args) {
Demo demo = new Demo();
Demo demo2 = new Demo();
Demo demo3 = demo2;boolean flg1 = demo3.equals(demo); boolean flg2 = demo3.equals(demo2);}
</pre>
六. String 类
-
定义
- String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。我们可以将字符串看作是String, 但是严格严格意义上来说, String还是一个类,只是比较特殊罢了
-
特殊性
String 类型的变量可以引用地址
String 类型的变量可以直接指向常量
String 对象的长度是不可变的,如果两个字符串拼接成一个字符串,其实是创建了一个新的字符串对象
<pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="java" cid="n183" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Monaco, Consolas, "Andale Mono", "DejaVu Sans Mono", monospace; margin-top: 0px; margin-bottom: 20px; background: rgb(51, 51, 51); font-size: 0.9rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; position: relative !important; padding: 10px 10px 10px 30px; width: inherit;">public static void main(String[] args) {
String str = new String();// 指向地址值
String str2 = "abc"; //指向常量
}
</pre> -
常用的构造方法
public String():空构造
public String(byte[] bytes):把字节数组转成字符串
public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
public String(char[] value):把字符数组转成字符串
public String(char[] value,int index,int count):把字符数组的一部分转成字符串
public String(String original):把字符串常量值转成字符串
-
测试题
-
判断定义为String类型的s1和s2是否相等?
String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2);
System.out.println(s1.equals(s2));
-
下面这句话在内存中创建了几个对象?
-
String s1 = new String("abc");
- 答案: 创建了两个看对象,一个在常量池,一个在堆内存
-
-
判断定义为String类型的s1和s2是否相等
String s1 = new String("abc");
String s2 = "abc";
System.out.println(s1 == s2);
System.out.println(s1.equals(s2));
-
判断定义为String类型的s1和s2是否相等?
String s1 = "a" + "b" + "c";
String s2 = "abc";
System.out.println(s1 == s2);
System.out.println(s1.equals(s2));
-
判断定义为String类型的s1和s2是否相等?
String s1 = "ab";
String s2 = "abc";
String s3 = s1 + "c";
System.out.println(s3 == s2);
System.out.println(s3.equals(s2));
-
-
常用的判断方法
boolean equals(Object obj): 比较字符串的内容是否相同,区分大小写
boolean equalsIgnoreCase(String str): 比较字符串的内容是否相同,忽略大小写
boolean contains(String str): 判断大字符串中是否包含小字符串
boolean startsWith(String str): 判断字符串是否以某个指定的字符串开头
boolean endsWith(String str): 判断字符串是否以某个指定的字符串结尾
boolean isEmpty(): 判断字符串是否为空
-
案例
需求：模拟登录,给三次机会,并提示还有几次。
用户名和密码都是admin
<pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="java" cid="n278" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Monaco, Consolas, "Andale Mono", "DejaVu Sans Mono", monospace; margin-top: 0px; margin-bottom: 20px; background: rgb(51, 51, 51); font-size: 0.9rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; position: relative !important; padding: 10px 10px 10px 30px; width: inherit;">public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int i = 1;
while(i<=3){
System.out.println("请输入用户名");
String name = scanner.nextLine();
System.out.println("请输入密码");
String password = scanner.nextLine();
if("admin".equals(name)&&"admin".equals(password)){
System.out.println("恭喜您,登录成功");
break;
}
System.out.println("用户名或密码错误,请您重新输入,您还有"+(3-i)+"次机会机会");
i++;
}
scanner.close();
}
</pre> -
测试题
查询一个某个班级中所有姓张的学生
String[] strs = {"李张蛋","张三","张飞","李伟","刘明"};
-
常用的获取方法
int length(): 获取字符串的长度
char charAt(int index): 获取指定索引位置的字符
int indexOf(int ch): 返回指定字符在此字符串中第一次出现处的索引, ch是字符的码表值
int indexOf(String str): 返回指定字符串在此字符串中第一次出现处的索引
int indexOf(int ch,int fromIndex): 返回指定字符在此字符串中从指定位置后第一次出现处的索引
int indexOf(String str,int fromIndex): 返回指定字符串在此字符串中从指定位置后第一次出现处的索引
int lastIndexOf 同上
String substring(int start):从指定位置开始复制字符串,默认到末尾
String substring(int start,int end):从指定位置开始到指定位置结束复制字符串
-
案例
- 需求：遍历字符串
<pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="java" cid="n312" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Monaco, Consolas, "Andale Mono", "DejaVu Sans Mono", monospace; margin-top: 0px; margin-bottom: 20px; background: rgb(51, 51, 51); font-size: 0.9rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; position: relative !important; padding: 10px 10px 10px 30px; width: inherit;">public static void main(String[] args) {
String str = "abcdkekdkgallsd";
for (int i = 0; i < str.length(); i++) {
System.out.println(str.charAt(i));
}
}
</pre> -
测试题
- 需求:不准使用charAt(),遍历字符串
-
常用的转换方法
byte[] getBytes(): 把字符串转换为字节数组
char[] toCharArray():把字符串转换为字符数组
static String valueOf(char[] chs):把字符数组转成字符串
-
static String valueOf(int i):把int类型的数据转成字符串
- 注意：String类的valueOf方法可以把任意类型的数据转成字符串
String toLowerCase():把字符串转成小写(了解)
String toUpperCase():把字符串转成大写
String concat(String str):把字符串拼接
-
案例
- 需求：把一个字符串的首字母转成大写，其余为小写
<pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="java" cid="n343" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Monaco, Consolas, "Andale Mono", "DejaVu Sans Mono", monospace; margin-top: 0px; margin-bottom: 20px; background: rgb(51, 51, 51); font-size: 0.9rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; position: relative !important; padding: 10px 10px 10px 30px; width: inherit;">public static void main(String[] args) {
String str = "abCdkeHgDlsd";
String str2 = str.substring(0,1).toUpperCase().concat(str.substring(1).toLowerCase());
System.out.println(str2);
}
</pre>
-
替换方法
String replace(char old,char new) : 将字符串中的一部分字符用新的代替
String replace(String old,String new) : 将字符串中的一部分字符串用新的代替
-
切割方法
String[] split(String regex) : 按照规则来切割字符串
String[] split(String regex, int limit) : 按照规则来切割字符串 limit 表示总共切成几段(也就是数组的长度)
-
其他常用方法 abc
trim() : 去除字符串前后的空格
int compareTo(String anotherString) : 按字典顺序比较两个字符串(大小写)
int compareToIgnoreCase(String str) : 按字典顺序比较两个字符串(忽略大小)
总结:
-
二维数组
- 数组中存放的还是数组
-
权限修饰符
- public protected 默认 private
-
java中的包
jvm识别类,要知道全名(包名+类名)
编译器有自动补全功能, 从类本上开始找 -- > import -- > package
-
Object
toString
hashCode
equals
getClass
== 和 equals的区别
equals相等的两个对象 hashCode一定相等, equals不等的两个对象, hashCode也有可能相等 (两个方法同步重写)
-
String
- 都要记
作业
-
第一题
需求：统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数,其他字符出现的次数。
ABCDEabcd123456!@#$%^
-
第二题
-
需求：把数组中的数据按照指定个格式拼接成一个字符串
-
举例：
int[] arr = {1,2,3};
-
输出结果：
[1, 2, 3]
-
-
-
第三题
-
需求：把字符串反转
举例：键盘录入"abc"
输出结果："cba"
-
-
第四题
-
需求：统计大串中小串出现的次数
大串: Adcddkiqooqkdddleef
小串: dd
-
-
第五题
- 将今天所有的常用方法全部练习2两遍
-
扩展题
-
需求: 去除一个字符串中相邻重复字符
举例: abbddAffeeEddcccwceaa
输出结果: abdAfeEdcwcea
-
