数组及其内存图解
二维数组:其实二维数组其实就是一个元素为一维数组的数组。
动态初始化方式一(指定有多少个长度相同的一维数组):
数据类型[][] 变量名 = new 数据类型[m][n];
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组有多少个一维数组
n表示每一个一维数组的元素个数
n表示每一个一维数组的元素个数
需求:请定义一个二维数组,二维数组有三个一维数组,每个一维数组有两个元素。
1.打印二维数组名称
2.打印每一个一维数组
3.不给元素赋值打印元素
4.赋值后打印元素
1.打印二维数组名称
2.打印每一个一维数组
3.不给元素赋值打印元素
4.赋值后打印元素
public class ArrayArrayDemo {
public static void main(String[] args) {
// 需求:请定义一个二维数组,二维数组有三个一维数组,每个一维数组有两个元素。
int[][] arr = new int[3][2];
// 1.打印二维数组名称
System.out.println(arr);//[[I@33abb81e
// 2.打印每一个一维数组
System.out.println(arr[0]);//[I@4ec4d412
System.out.println(arr[1]);//[I@5c3f1224
System.out.println(arr[2]);//[I@30c028cc
// 3.不给元素赋值打印元素
//二维数组中的第一个一位数组的0号元素
System.out.println(arr[0][0]);//0
System.out.println(arr[1][1]);//0
// 4.赋值后打印元素
arr[1][0] = 10;
arr[2][0] = 20;
System.out.println(arr[1][0]);
System.out.println(arr[2][0]);
}
}
需要注意的点:.给二维数组的每一个一维数组的元素赋值
仅可用此种方式:
arr[0] = new int[2];
arr[0][0] = 1;
arr[0][1] = 2;
不能用此种方式:
/*
arr[0] = {1,2};
arr[1] = {5,6,7};
arr[2] = {4};
*/
二维数组的求和例题:
package com.edu_01; public class ArrayArrayDemo5 { public static void main(String[] args) { /** * 2.5 二维数组的求和: 公司年销售额求和 某公司按照季度和月份统计的数据如下:单位(万元) 第一季度:22,66,44 第二季度:77,33,88 第三季度:25,45,65 第四季度:11,66,99 */ //创建对应的二维数组 int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}}; //遍历二维数组并将每一个元素的值加起来 int sum = 0; for (int i = 0; i < arr.length; i++) { //拿到每一个一维数组之后,遍历每一个一维数组,加起来 for (int j = 0; j < arr[i].length; j++) { sum+=arr[i][j]; } } System.out.println(sum);
]
]
]
三:形式参数问题 看程序写结果(画内存图进行分析) class ArgsDemo { public static void main(String[] args){ int a = 10; int b = 20; System.out.println("a:"+a+",b:"+b); //10,20 change(a,b); System.out.println("a:"+a+",b:"+b); //?
int[] arr = {1,2,3,4,5}; change(arr); System.out.println(arr[1]); //4 }
public static void change(int a,int b) { System.out.println("a:"+a+",b:"+b); //10,20 a = b; b = a + b; System.out.println("a:"+a+",b:"+b);/20,40 }
public static void change(int[] arr) { for(int x=0; x<arr.length; x++) { //如果数组的元素值是偶数,就变为以前的2倍。 if(arr[x]%2==0) { arr[x]*=2; } } } } 结论: 如果形式参数是基本类型: 形式参数的改变,不影响实际参数。 如果形式参数是引用类型: 形式参数的该变,直接影响实际值
数组的高级操作
1 冒泡排序
2 选择排序
三:Arrays数组工具类 3.1 针对数组进行操作的工具类。提供了排序,转换等功能。3.2 * 成员方法: * public static String toString(int[] a):把数组转成字符串 * public static void sort(int[] a):对数组进行排序(有重载)例题;package com.edu_04; import java.util.Arrays; public class ArraysDemo2 { public static void main(String[] args) { //public static String toString(int[] a):把数组转成字符串 int[] arr = {1,2,4,5,5}; //打印上面数组的字符串表示形式 String arrStr = Arrays.toString(arr); System.out.println(arrStr); System.out.println("----------"); char[] chs = {'a','d','f','g'}; String chsStr = Arrays.toString(chs); System.out.println(chsStr); } }
继承与需求
如何表达这个关系呢?
通过extends关键字可以实现类与类的继承
格式:
class 子类名 extends 父类名 {
}
父类:基类,超类
子类:派生类
需求:
学生类:
成员变量:name,age
构造方法:无参,带参
成员方法:getXxx()/setXxx(),eat(),sleep()
老师类:
成员变量:name,age
构造方法:无参,带参
成员方法:getXxx()/setXxx(),eat(),sleep()
非继承版代码
1.2
需求:(需要加入方法重写)
学生类:
成员变量:name,age
构造方法:无参,带参
成员方法:getXxx()/setXxx(),eat(),sleep()
老师类:
成员变量:name,age
构造方法:无参,带参
成员方法:getXxx()/setXxx(),eat(),sleep()
public class Person {
//私有化成员变量
private String name;
private int age;
//set/get方法
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
//有参数和无参数的构造
public Person(){}
public Person(String name,int age){
this.name = name;
this.age = age;
}
//吃饭和睡觉的方法
public void eat(){
System.out.println("民以食为天");
}
public void sleep(){
System.out.println("睡觉也是个大事情");
}
}
final关键字
在实际开发的时候,有些方法的内容一旦写定后,就不允许被改动。
即时是子类,也不允许。那么该怎么解决这个问题呢?
java为了解决这样的问题就提供了一个关键字:final
final:
最终的意思。它可以修饰类,方法,变量。
特点:
修饰方法,方法不能被重写。
修饰类,类不能被继承。
修饰变量,变量的值不能再改动。其实这个时候变量已经变成了常量。
常量:
A:字面值常量
'a',12,"hello"
B:自定义常量
就是把变量用final修饰。
定义一个常量。
final 数据类型 变量名;
class Fu{//一个类如果被final修饰过后,就不能被继承
//写一个被final修饰的方法
public final void eat(){
System.out.println("fu的eat()");
}
}
class Zi extends Fu{
//尝试重写父类中的eat(),子类复发重写父类中被final修饰过的方法
/*public void eat(){
}*/
final int NUM = 20;
//自定义一个常量,这个常量有多个单词组成
final int MAX_AGE = 30;
final String URL = "WWW.BAIDU.COM";
}
public class FinalDemo {
public static void main(String[] args) {
//创建Zi的对象,访问他的被final修饰过的成员变量num
Zi z = new Zi();
//尝试改变被final修饰过的成员变量num
//z.num = 30;//被final修饰过的变量不能被更改,此时他已经成了常量
System.out.println(z.NUM);
}
}
五:接口
5.1 认识接口:不是我们现实生活中的usb接口等等实物的接口,类实现接口代表着这个类自身功能的一种扩展,
所以接口代表着一种扩展的能力
5.2
接口的特点:
A:定义接口要用关键字interface表示
格式:interface 接口名 {}
B:类实现接口用implements表示
格式:class 类名 implements 接口名 {}
C:接口不能实例化
那么,接口如何实例化呢?
按照多态的方式,由具体的子类实例化。其实这也是多态的一种,接口多态。
D:接口的实现类
要么是抽象类
要么重写接口中的所有抽象方法
多态的前提:
A:有继承或者实现关系
B:有方法重写
C:有父类引用或者父接口引用指向子类或者实现类对象
多态分类:
A:具体类多态
B:抽象类多态
C:接口多态
5.3
接口的成员特点:
A:成员变量
只能是常量。
默认修饰符:public static final
B:构造方法
没有构造方法
C:成员方法
只能是抽象方法。
默认修饰符:public abstract
5.4
类与类:
继承关系。只能单继承,可以多层(重)继承。
类与接口:
实现关系。可以单实现,也可以多实现。
还可以在继承一个类的同时实现多个接口。
接口与接口:
继承关系。可以单继承,也可以多继承。
5.5
接口和抽象类的关系最后分析:
抽象类和接口的区别
A:成员区别
抽象类:
成员变量:可以是变量,也可以是常量
构造方法:有构造方法
成员方法:可以是抽象方法,也可以是非抽象方法
接口:
成员变量:只能是常量。默认修饰符 public static final
成员方法:只能是抽象方法。默认修饰符 public abstract
B:关系区别
类与类:
继承关系。只能单继承,可以多层(重)继承。
类与接口:
实现关系。可以单实现,也可以多实现。
还可以在继承一个类的同时实现多个接口。
接口与接口:
继承关系。可以单继承,也可以多继承。
C:设计理念区别
抽象类被继承体现的是:"is a"的关系。抽象类定义的是共性功能。
接口被实现体现的是:"like a"的关系。接口定义的是扩展功能。
5.6
继承,抽象类,接口代码综合演练
分析:从具体到抽象
实现:从抽象到具体
使用:使用具体类
猫狗案例,加入跳高的额外功能
猫:
成员变量:
name,age
构造方法:
无参,带参
成员方法:
getXxx()/setXxx()
show()
catchMouse()
eat()
跳高猫:继承自猫
成员方法:
跳高
狗:
成员变量:
name,age
构造方法:
无参,带参
成员方法:
getXxx()/setXxx()
show()
lookDoor()
eat()
跳高狗:继承自狗
成员方法:
跳高
无论猫还是狗,都是动物,所以我们提取出一个动物类:
跳高接口:
跳高
动物类:抽象类
成员变量:
name,age
构造方法:
无参,带参
成员方法:
getXxx()/setXxx()
show(){}
eat(); 抽象方法
猫:继承自动物
构造方法:
无参,带参
成员方法:
catchMouse()
eat()
跳高猫:继承自猫,实现跳高接口
构造方法:
无参,带参
成员方法:
跳高
狗:继承自动物
构造方法:
无参,带参
成员方法:
lookDoor()
eat()
跳高狗:继承自狗,实现跳高接口
构造方法:
无参,带参
成员方法:
跳高
类与类:
继承关系。只能单继承,可以多层(重)继承。
类与接口:
实现关系。可以单实现,也可以多实现。
还可以在继承一个类的同时实现多个接口。
接口与接口:
继承关系。可以单继承,也可以多继承。
*
*/
interface Inter1{}
interface Inter2{}
interface Inter3 extends Inter2,Inter1{}
//创建一个类实现一个接口,或者多个接口
class InterImpl3 implements Inter1,Inter2{}
//一个类还可以在继承一个类的同时实现多个接口
class InterImpl4 extends InterImpl3 implements Inter3{}
public class InterfaceDemo2 {
}
如何表达这个关系呢?
通过extends关键字可以实现类与类的继承
class 子类名 extends 父类名 {
}
子类:派生类
学生类:
成员变量:name,age
构造方法:无参,带参
成员方法:getXxx()/setXxx(),eat(),sleep()
成员变量:name,age
构造方法:无参,带参
成员方法:getXxx()/setXxx(),eat(),sleep()
非继承版代码
需求:(需要加入方法重写)
学生类:
成员变量:name,age
构造方法:无参,带参
成员方法:getXxx()/setXxx(),eat(),sleep()
老师类:
成员变量:name,age
构造方法:无参,带参
成员方法:getXxx()/setXxx(),eat(),sleep()
public class Person {
//私有化成员变量
private String name;
private int age;
//set/get方法
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
//有参数和无参数的构造
public Person(){}
public Person(String name,int age){
this.name = name;
this.age = age;
}
//吃饭和睡觉的方法
public void eat(){
System.out.println("民以食为天");
}
public void sleep(){
System.out.println("睡觉也是个大事情");
}
}
在实际开发的时候,有些方法的内容一旦写定后,就不允许被改动。
即时是子类,也不允许。那么该怎么解决这个问题呢?
java为了解决这样的问题就提供了一个关键字:final
最终的意思。它可以修饰类,方法,变量。
修饰方法,方法不能被重写。
修饰类,类不能被继承。
修饰变量,变量的值不能再改动。其实这个时候变量已经变成了常量。
A:字面值常量
'a',12,"hello"
B:自定义常量
就是把变量用final修饰。
class Fu{//一个类如果被final修饰过后,就不能被继承
//写一个被final修饰的方法
public final void eat(){
System.out.println("fu的eat()");
}
}
class Zi extends Fu{
//尝试重写父类中的eat(),子类复发重写父类中被final修饰过的方法
/*public void eat(){
}*/
final int NUM = 20;
//自定义一个常量,这个常量有多个单词组成
final int MAX_AGE = 30;
final String URL = "WWW.BAIDU.COM";
}
public class FinalDemo {
public static void main(String[] args) {
//创建Zi的对象,访问他的被final修饰过的成员变量num
Zi z = new Zi();
//尝试改变被final修饰过的成员变量num
//z.num = 30;//被final修饰过的变量不能被更改,此时他已经成了常量
System.out.println(z.NUM);
}
}
五:接口
5.1 认识接口:不是我们现实生活中的usb接口等等实物的接口,类实现接口代表着这个类自身功能的一种扩展,
所以接口代表着一种扩展的能力
5.1 认识接口:不是我们现实生活中的usb接口等等实物的接口,类实现接口代表着这个类自身功能的一种扩展,
所以接口代表着一种扩展的能力
5.2
接口的特点:
A:定义接口要用关键字interface表示
格式:interface 接口名 {}
B:类实现接口用implements表示
格式:class 类名 implements 接口名 {}
C:接口不能实例化
那么,接口如何实例化呢?
按照多态的方式,由具体的子类实例化。其实这也是多态的一种,接口多态。
D:接口的实现类
要么是抽象类
要么重写接口中的所有抽象方法
接口的特点:
A:定义接口要用关键字interface表示
格式:interface 接口名 {}
B:类实现接口用implements表示
格式:class 类名 implements 接口名 {}
C:接口不能实例化
那么,接口如何实例化呢?
按照多态的方式,由具体的子类实例化。其实这也是多态的一种,接口多态。
D:接口的实现类
要么是抽象类
要么重写接口中的所有抽象方法
多态的前提:
A:有继承或者实现关系
B:有方法重写
C:有父类引用或者父接口引用指向子类或者实现类对象
A:有继承或者实现关系
B:有方法重写
C:有父类引用或者父接口引用指向子类或者实现类对象
多态分类:
A:具体类多态
B:抽象类多态
C:接口多态
5.3
接口的成员特点:
A:成员变量
只能是常量。
默认修饰符:public static final
B:构造方法
没有构造方法
C:成员方法
只能是抽象方法。
默认修饰符:public abstract
5.4
类与类:
继承关系。只能单继承,可以多层(重)继承。
类与接口:
实现关系。可以单实现,也可以多实现。
还可以在继承一个类的同时实现多个接口。
A:具体类多态
B:抽象类多态
C:接口多态
5.3
接口的成员特点:
A:成员变量
只能是常量。
默认修饰符:public static final
B:构造方法
没有构造方法
C:成员方法
只能是抽象方法。
默认修饰符:public abstract
5.4
类与类:
继承关系。只能单继承,可以多层(重)继承。
类与接口:
实现关系。可以单实现,也可以多实现。
还可以在继承一个类的同时实现多个接口。
接口与接口:
继承关系。可以单继承,也可以多继承。
5.5
接口和抽象类的关系最后分析:
抽象类和接口的区别
A:成员区别
抽象类:
成员变量:可以是变量,也可以是常量
构造方法:有构造方法
成员方法:可以是抽象方法,也可以是非抽象方法
接口:
成员变量:只能是常量。默认修饰符 public static final
成员方法:只能是抽象方法。默认修饰符 public abstract
B:关系区别
类与类:
继承关系。只能单继承,可以多层(重)继承。
类与接口:
实现关系。可以单实现,也可以多实现。
还可以在继承一个类的同时实现多个接口。
继承关系。可以单继承,也可以多继承。
5.5
接口和抽象类的关系最后分析:
抽象类和接口的区别
A:成员区别
抽象类:
成员变量:可以是变量,也可以是常量
构造方法:有构造方法
成员方法:可以是抽象方法,也可以是非抽象方法
接口:
成员变量:只能是常量。默认修饰符 public static final
成员方法:只能是抽象方法。默认修饰符 public abstract
B:关系区别
类与类:
继承关系。只能单继承,可以多层(重)继承。
类与接口:
实现关系。可以单实现,也可以多实现。
还可以在继承一个类的同时实现多个接口。
接口与接口:
继承关系。可以单继承,也可以多继承。
C:设计理念区别
抽象类被继承体现的是:"is a"的关系。抽象类定义的是共性功能。
接口被实现体现的是:"like a"的关系。接口定义的是扩展功能。
5.6
继承,抽象类,接口代码综合演练
分析:从具体到抽象
实现:从抽象到具体
使用:使用具体类
继承关系。可以单继承,也可以多继承。
C:设计理念区别
抽象类被继承体现的是:"is a"的关系。抽象类定义的是共性功能。
接口被实现体现的是:"like a"的关系。接口定义的是扩展功能。
5.6
继承,抽象类,接口代码综合演练
分析:从具体到抽象
实现:从抽象到具体
使用:使用具体类
猫狗案例,加入跳高的额外功能
猫:
成员变量:
name,age
构造方法:
无参,带参
成员方法:
getXxx()/setXxx()
show()
catchMouse()
eat()
成员变量:
name,age
构造方法:
无参,带参
成员方法:
getXxx()/setXxx()
show()
catchMouse()
eat()
跳高猫:继承自猫
成员方法:
跳高
成员方法:
跳高
狗:
成员变量:
name,age
构造方法:
无参,带参
成员方法:
getXxx()/setXxx()
show()
lookDoor()
eat()
成员变量:
name,age
构造方法:
无参,带参
成员方法:
getXxx()/setXxx()
show()
lookDoor()
eat()
跳高狗:继承自狗
成员方法:
跳高
成员方法:
跳高
无论猫还是狗,都是动物,所以我们提取出一个动物类:
跳高接口:
跳高
跳高
动物类:抽象类
成员变量:
name,age
构造方法:
无参,带参
成员方法:
getXxx()/setXxx()
show(){}
eat(); 抽象方法
成员变量:
name,age
构造方法:
无参,带参
成员方法:
getXxx()/setXxx()
show(){}
eat(); 抽象方法
猫:继承自动物
构造方法:
无参,带参
成员方法:
catchMouse()
eat()
构造方法:
无参,带参
成员方法:
catchMouse()
eat()
跳高猫:继承自猫,实现跳高接口
构造方法:
无参,带参
成员方法:
跳高
构造方法:
无参,带参
成员方法:
跳高
狗:继承自动物
构造方法:
无参,带参
成员方法:
lookDoor()
eat()
构造方法:
无参,带参
成员方法:
lookDoor()
eat()
跳高狗:继承自狗,实现跳高接口
构造方法:
无参,带参
成员方法:
跳高
构造方法:
无参,带参
成员方法:
跳高
类与类:
继承关系。只能单继承,可以多层(重)继承。
类与接口:
实现关系。可以单实现,也可以多实现。
还可以在继承一个类的同时实现多个接口。
接口与接口:
继承关系。可以单继承,也可以多继承。
*
*/
interface Inter1{}
interface Inter2{}
interface Inter3 extends Inter2,Inter1{}
//创建一个类实现一个接口,或者多个接口
class InterImpl3 implements Inter1,Inter2{}
//一个类还可以在继承一个类的同时实现多个接口
class InterImpl4 extends InterImpl3 implements Inter3{}
public class InterfaceDemo2 {
}