JAVA笔记复习2

数组及其内存图解

二维数组：其实二维数组其实就是一个元素为一维数组的数组。

 动态初始化方式一（指定有多少个长度相同的一维数组）：
  数据类型[][] 变量名 = new 数据类型[m][n];

  m表示这个二维数组有多少个一维数组
  n表示每一个一维数组的元素个数

需求：请定义一个二维数组,二维数组有三个一维数组,每个一维数组有两个元素。
 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 {

}