稀疏数组
- 把具有不同值的元素和行列及值记录在一个小规模的数组中,从而缩小程序的规模
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wQwfCAI5-1593350273503)(C:\Users\Administrator\Desktop\图片\稀疏数组.png)]
//稀疏数组
public class ArrayDemo2 {
public static void main(String[] args) {
//1.创建一个二维数组 11*11 0:没有棋子 1:黑棋 2:白棋
int[][] array1=new int[11][11];
array1[1][2]=1;
array1[2][3]=2;
//输出原始数组
System.out.println("输出原始数组:");
for (int[] ints : array1) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
System.out.println("=============");
//转换为稀疏数组保存
//获取有效的个数
int sum=0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (array1[i][j]!=0){
sum++;
}
}
}
System.out.println("有效值的个数:"+sum);
int[][] array2=new int[sum+1][3];
array2[0][0]=11;
array2[0][1]=11;
array2[0][2]=sum;
//遍历二维数组,将非零的值,存放到稀疏数组中
int count=0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {
if (array1[i][j]!=0){
count++;
array2[count][0]=i;
array2[count][1]=j;
array2[count][2]=array1[i][j];
}
}
}
//输出稀疏数组
System.out.println("输出稀疏数组:");
for (int i = 0; i < array2.length; i++) {
for (int j = 0; j < array2.length; j++) {
System.out.print(array2[i][j]+"\t");
}
System.out.println();
}
System.out.println("================");
System.out.println("还原");
//1.读取稀疏数组
int[][] array3=new int[array2[0][0]][array2[0][1]];
//2.给其中的元素还原它的值
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]]=array2[i][2];
}
//3.打印
System.out.println("输出还原数组:");
for (int[] ints : array3) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
}
}
抽象类
- 不能new这个抽象类,只能靠子类去实现它:约束!
- 抽象类中可以写普通的方法
- 抽象方法必须在抽象类中~
- 抽象类只能单继承
思考题
抽象类中存在构造器吗?
可以有构造器,只是不能直接创建抽象类的实例对象
抽象类存在的意义?
抽象出来~ 提高开发效率
接口
- 普通类:只有具体实现
- 抽象类:具有实现和规范(抽象方法)都有!
- 接口只有规范!自己无法写方法~专业的约束! 约束和实现分离:面向接口编程
- 可以实现多个接口 implement
- 必须重写接口中的方法
//接口中定义的属性都是常量 public static final int AGE=99
int AGE=99;
//接口中所有的定义的方法都是抽象的 public abstract add(String name);
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
封装
高内聚,低耦合
- 高内聚就是类的内部数据操作细节自己完成,不允许外部干涉;低耦合:仅暴露少量的方法给外部使用(该露的露,该藏的藏)
封装(数据的隐藏)
- 通常,应禁止直接访问一个对象中的实际表示,而应通过操作接口来访问,这称为信息隐藏
- 属性私有,get/set
内部类
- 成员内部类
- 静态内部类
- 局部内部类
- 匿名内部类
public class Outer {
private int id=10;
public void out(){
System.out.println("外部类方法");
}
public class Inner{
public void in(){
System.out.println("内部类方法");
}
//获得外部类的私有属性
public void getID(){
System.out.println("外部类id:"+id);
}
}
//局部内部类
public void method(){
class B{
}
}
}
//一个类中只有一个public class类可以有很多class A~类
class A{
public static void main(String[] args) {
}
}
public class Application {
public static void main(String[] args) {
//外部类
Outer outer = new Outer();
//通过外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.getID();
//匿名内部类
//没有名字初始化类,不用讲实例保存到变量中
new Outer().method();
}
}