java基础（笔记）三

一：

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

动态初始化方式一（指定有多少个长度相同的一维数组）：

数据类型[][] 变量名 = new 数据类型[m][n];

m表示这个二维数组有多少个一维数组

n表示每一个一维数组的元素个数

2.2

动态初始化方式二（指定二维数组中有多少个一维数组，每一个一维数组的长度不固定）：

数据类型[][] 变量名 = new 数据类型[m][];

注意：

m这个数据必须给出，后面的数据可以不给

        .给这个二维数组的每一个一维数组的元素赋值

仅可用此种方式：

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};

*/

画出内存图解

2.3

二维数组的静态初始化：

静态初始化：

数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};

简化格式：

数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};

例一：public class ArrayArrayDemo5 {
public static void main(String[] args) {
/**
*  二维数组的求和：
公司年销售额求和
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：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);
}


}

二：形式参数问题

如果形式参数是基本类型：

形式参数的改变，不影响实际参数。

如果形式参数是引用类型：

形式参数的该变，直接影响实际参数。

例二：   public 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); //a:10,b:20


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.1 冒泡排序基本概念是：

相邻的两个元素进行比较，小的放前面，大的放后面

例3：public class ArraySortDemo {
public static void main(String[] args) {
int[] arr = { 24, 69, 80, 57, 13 };
for (int j = 0; j < arr.length-1; j++) {//外层循环控制比较的次数
for (int i = 0; i < arr.length - 1 - j ; i++) {
//-1是为了防止数组越界，-j是为了提高比较的效率
if (arr[i]>arr[i+1]) {
//找一个中间变量
int temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
}
printArr(arr);
}
//写一个方法打印数组
public static void printArr(int[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+"  ");
}
System.out.println();
}
}

（二）：选择排序：

2.1 选择排序概念：

 * 选择排序：

 * 从0索引开始，依次和后面的每一个元素进行比较

 * 第一次比较完毕，最小值出现在了最小索引处

 * 第二次比较完毕，次小值出现在了次小索引处

 * ...

 * 完毕后，就排序了。

例4：public class ArraySortDemo2 {
public static void main(String[] args) {
int[] arr = { 24, 69, 80, 57, 13 };
for (int j = 0; j < arr.length-1; j++) {
for (int i = j+1; i < arr.length; i++) {
if (arr[j]>arr[i]) {
int temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
}
}
printArr(arr);

}
//写一个方法打印数组
public static void printArr(int[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+"  ");
}
System.out.println();
}
}

（三）：Arrays数组工具类

3.1 针对数组进行操作的工具类。提供了排序，转换等功能。

3.2

 * 成员方法：

 * public static String toString(int[] a):把数组转成字符串

 * public static void sort(int[] a):对数组进行排序（有重载）

四：继承

如何表达这个关系呢?

通过extends关键字可以实现类与类的继承

格式：

class 子类名 extends父类名 {

}

父类：基类，超类

子类：派生类

继承的好处：

A:提高了代码的复用性

多个类相同的成员可以放到同一个类中

B:提高了代码的维护性

如果功能的代码需要修改，修改一处即可

C:让类与类之间产生了关系，是多态的前提

方法重写(子类的方法名，参数和父类完全一样，将父类方法覆盖)：

1.必须存在继承关系

2.父类的方法满足不了你的需求，此时你就需要重写父类的方法，实现自己想要实现的功能

 例：

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("睡觉也是件大事");

}
}

public class Student extends Person {
public void eat(){
System.out.println("学生喜欢吃米饭");
}
}

public class Teacher extends Person {
    public void eat(){
    System.out.println("老师喜欢吃面条");
    }
}

public class Test {
     public static void main(String[] args) {
Student s=new Student();
s.eat();
s.sleep();
System.out.println("-----------------");
Teacher t=new Teacher();
t.eat();
t.sleep();
     }
}

4.3

继承的特点：（代码演示）

A:Java只支持单继承，不支持多继承。

B:Java支持多层(重)继承(继承体系)。

4.4

类的组成：

成员变量

构造方法

成员方法

继承间的成员变量关系：

A:名字不同，非常简单。

B:名字相同

首先在子类局部范围找，然后在子类成员范围找，最后在父类成员范围找(肯定不能访问到父类局部范围)。如果还是没有就报错。(不考虑父亲的父亲…)就近原则。

怎么去访问父亲的成员呢?

java就提供了一个关键字：super

super:

super代表父类存储空间的标识(可以理解为父类对象)

this和super的使用区别?

A:成员变量

this.成员变量 本类的成员变量

super.成员变量 父类的成员变量

B:成员方法

this.成员方法() 本类的成员方法

super.成员方法()父类的成员方法

例：class Fu{
int num=10;
int num4=50;
}
class Zi extends Fu{
int num=20;
int num2=30;
void show(){
int num=40;
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
System.out.println(num2);
System.out.println(num4);
}

}
public class EztendsDemo1 {
   public static void main(String[] args) {
Zi z=new Zi();
z.show();
}
}

4.5

继承间的成员方法关系：

A:方法名不同，非常简单

B:方法名相同

首先在子类中找

然后在父类中找

如果还是没有就报错。(不考虑父亲的父亲…)

4.6

继承间构造方法的关系：

子类中所有的构造方法默认都会访问父类中空参数的构造方法(super())

为什么呢?

因为子类会继承父类中的数据，可能还会使用父类的数据。

所以，子类初始化之前，一定要先完成父类数据的初始化。

每个子类的构造方法的第一行，有一条默认的语句:

super();

注意：仅仅是完成数据的初始化，创建对象目前必须用new申请空间。

假如父类没有无参构造方法,该怎么办呢?

A:调用父类的其他构造方法。带参构造。

怎么访问呢?

super(...)

 

注意：

super(…)或者this(….)必须出现在第一条语句上。

因为如果可以放后面的话，就会对父类的数据进程多次初始化。所以，只能放在第一条语句上。

建议：

永远给出无参构造方法。

五：final关键字

在实际开发的时候，有些方法的内容一旦写定后，就不允许被改动。

即时是子类，也不允许。那么该怎么解决这个问题呢?

java为了解决这样的问题就提供了一个关键字：final

final:

最终的意思。它可以修饰类,方法,变量。

特点：

修饰方法，方法不能被重写。

修饰类，类不能被继承。

修饰变量，变量的值不能再改动。其实这个时候变量已经变成了常量。

常量：

A:字面值常量

'a',12,"hello"

B:自定义常量

就是把变量用final修饰。

定义一个常量。

final 数据类型 变量名;

六：多态

6.1多态：同一个对象,在不同时刻表现出来的不同状态

举例：

A:猫

猫是猫

猫是动物

B:水

水(液态)

冰(固态)

水蒸气(气态)

多态的前提：

A:有继承关系

B:有方法重写（不是必要条件，但是只有有了方法重写多态才有意义）

C:有父类引用指向子类对象

Fu f = new Fu();

左边：Fu类型的引用

右边：Fu类型的对象

Zi z = new Zi();

Fu f = new Zi();

6.2

成员访问特点

A:成员变量

编译看左边,运行看左边

B:构造方法

子类构造默认访问父类的无参构造

C:成员方法（重点理解）

编译看左边,运行看右边

 

为什么变量和方法不一样呢?

方法重写。

D:静态成员方法

编译看左边,运行看左边

因为静态的内容是和类相关的，与对象无关。

七：抽象类

7.1抽象类特点:

A:抽象类和抽象方法必须用abstract关键字修饰

B:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类

C:抽象类不能实例化

那么，如果实例化并使用呢?

按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。

D:抽象类的子类

要么是抽象类

要么重写抽象类中的所有抽象方法

抽象类的作用：

强制要求子类必须要重写某些方法。

7.2

抽象类 -- 特点 -- 成员特点 -- 案例

类的组成：

成员变量：

构造方法：

成员方法：

抽象类的成员：

成员变量：可以是变量，也可以是常量。

构造方法：有构造方法

不能实例化,构造方法有什么用呢?

用于子类访问父类数据的初始化。

成员方法：既可以是抽象的，也可以是非抽象的。

7.3 抽象类练习

以后我们在写代码的时候，有这样的分析过程。

分析：

从具体到抽象。

实现：

从抽象到具体。

 

使用：

使用具体的类。

多态：

具体类多态

class Fu {}

class Zi extends Fu {}

抽象类多态

abstract class Fu {}

class Zi extends Fu {}

接口多态

多态的前提：

继承

方法重写

因为抽象类中的方法是抽象方法。

父类引用指向子类对象

八：接口

8.1 认识接口：不是我们现实生活中的usb接口等等实物的接口，类实现接口代表着这个类自身功能的一种扩展，

    所以接口代表着一种扩展的能力

8.2

接口的特点：

A:定义接口要用关键字interface表示

格式：interface 接口名 {}

B:类实现接口用implements表示

格式：class 类名 implements 接口名{}

C:接口不能实例化

那么，接口如何实例化呢?

按照多态的方式，由具体的子类实例化。其实这也是多态的一种，接口多态。

D:接口的实现类

要么是抽象类

要么重写接口中的所有抽象方法

多态的前提：

A:有继承或者实现关系

B:有方法重写

C:有父类引用或者父接口引用指向子类或者实现类对象

多态分类：

A:具体类多态

B:抽象类多态

C:接口多态

8.3

接口的成员特点：

A:成员变量

只能是常量。

默认修饰符：public static final

B:构造方法

没有构造方法

C:成员方法

只能是抽象方法。

默认修饰符：public abstract

8.4

类与类：

继承关系。只能单继承，可以多层(重)继承。

类与接口：

实现关系。可以单实现，也可以多实现。

还可以在继承一个类的同时实现多个接口。

 

接口与接口：

继承关系。可以单继承，也可以多继承。

8.5

接口和抽象类的关系最后分析：

抽象类和接口的区别

A:成员区别

抽象类：

成员变量：可以是变量，也可以是常量

构造方法：有构造方法

成员方法：可以是抽象方法，也可以是非抽象方法

接口：

成员变量：只能是常量。默认修饰符 public static final

成员方法：只能是抽象方法。默认修饰符 public abstract

B:关系区别

类与类：

继承关系。只能单继承，可以多层(重)继承。

类与接口：

实现关系。可以单实现，也可以多实现。

还可以在继承一个类的同时实现多个接口。

 

接口与接口：

继承关系。可以单继承，也可以多继承。

C:设计理念区别

抽象类被继承体现的是："is a"的关系。抽象类定义的是共性功能。

接口被实现体现的是："like a"的关系。接口定义的是扩展功能。

8.6

继承，抽象类，接口代码综合演练

分析：从具体到抽象

实现：从抽象到具体

使用：使用具体类

九：形式参数问题

数据类型：

基本类型：byte,short,int,long,float,double,char,boolean

引用类型：类,接口,数组

形式参数：

基本类型：要的是该基本类型的数据值。

引用类型：要的是该引用类型的对象。

A:数组 要的是该数据类型数组的对象。(地址值)

B:类   要的是该类或者其子类的对象。(地址值)

C:抽象类 要的是该抽象类的子类对象。(地址值)

D:接口 要的是该接口的实现类对象。(地址值)

十：返回值问题

返回值：

基本类型：byte,short,int,long,float,double,char,boolean

引用类型：类，接口，数组

返回值之基本类型：

基本类型：返回的是该基本类型的数据值。

案例：创建一个加法的方法，返回值就是基本类型的具体的指

返回值之引用类型：

返回值是类名：其实返回的是该类对象或者其子类对象。(地址值)

返回值是抽象类名：要的是该抽象类的子类对象。(地址值)

返回值是接口名：要的是该接口的实现类对象。(地址值)

十一：权限修饰符（代码进行测试）

权限修饰符：在哪种情况下可以被访问到。

本类     同一个包下的类   不同包下的子类 不同包下的无关类

private yes no no no

默认(什么都不写) yes yes no no

protected yes             yes       no no

public yes             yes yes yes

 

十二：常见的内容修饰

1:常见的修饰

类：public

public class HelloWorld {}

 

成员变量：private

private String name;

private int age;

构造方法：public

public Student() {}

public Student(String name,int age) {}

成员方法：public

public void show() {}

public void eat() {}

2:哪些东西可以修饰哪些东西

    类 成员变量 构造方法 成员方法

private Y         Y Y

默认 Y Y         Y Y

protected Y Y Y

public Y Y Y Y

static Y Y

final Y Y Y

abstract Y Y

注意：

四种权限修饰符，只能有一种存在。

class Demo {}

常见的组合：

类：

public class HelloWorld {}

public final class HelloWorld {}

public abstract class HelloWorld {}

成员变量：

private String name;

public final int X = 10;

public static int y = 20;

public static final int X = 30;

成员方法：

public void show(){}

public abstract void show();

public final void show(){}

public static void show() {}

public static final void show() {}

十三：内部类

13.1

内部类：

把类A定义在类B的内部，类A就被称为内部类。

访问特点：（代码验证只要编译通过说明就是没有问题的）

A:内部类可以直接访问外部类的成员，包括私有。

B:外部类要访问内部类的成员，必须创建对象。

13.2

内部类分类：

成员位置：成员内部类

局部位置：局部内部类

13.2.1

成员内部类：

外界如何创建对象

外部类名.内部类名 对象名= 外部类对象.内部类对象;

13.2.2

内部类的关键词限定：

内部类举例：

Body,Heart

//A:private 为了我们访问数据的安全性

class Body {

private class Heart {

public void operator() {

System.out.println("给心脏搭个桥");

}

}

 

public void method() {

if(你是医生吗?) {

Heart h = new Heart();

h.operator();

}

}

}

 

直接访问：

Body.Heart bh = new Body().new Heart();

bh.operator();

为了身体的安全，外界是不能让他们直接创建对象。通过private进行修饰。

这个时候就可以这样来使用：

Body b = new Body();

b.method();

成员内部类的修饰：

A:private 为了我们访问数据的安全性

B:static  为了我们访问数据的方便性

13.3

局部内部类：

A:可以直接访问外部类的成员，包括私有

B:在成员方法中创建局部内部类的对象，调用局部内部类的功能