JavaSE进阶笔记

JavaSE进阶

第一篇文章的连接： （超详细笔记整理）动力节点_老杜 | JavaSE零基础 ：P329（方法） - P479.

final关键字

1. final是Java语言中的关键字

2. final表示最终的，不可变的

3. final可以修饰变量以及方法还有类等

4. final修饰的变量

5. final修饰的局部变量无法重新赋值，final修饰的变量只能赋一次值

6. final修饰的方法

final修饰的方法无法覆盖

7. final修饰的类

final修饰的类无法继承

package Final;
/*
 final
    1. final是Java语言中的关键字
    2. final表示最终的，不可变的
    3. final可以修饰变量以及方法还有类等
    4. final修饰的变量
        final修饰的局部变量无法重新赋值，final修饰的变量只能赋一次值
    5. final修饰的方法
        final修饰的方法无法覆盖
    6. final修饰的类
        final修饰的类无法继承

/
public class Test01 {
public static void main(String[] args){
//局部变量
int i = 100;
i = 200;
/
final int k = 100;
k = 0;
*/
}
}
//继承
//如果你不希望别人对A类进行扩展，那么可以给A类加上final
final class A{

}
/*
final修饰的类无法继承
class B extends A{

}*/
//方法覆盖
class C{
public final void doSome(){
System.out.println(“C”);
}
}
class D extends C{
//无法被覆盖
/public void doSome(){
System.out.println(“D”);
}/
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47

8. final修饰的引用

该引用只能指向一个对象，并且它只能永远指向该对象。无法再指向其他对象。并且再该方法执行过程中，该引用指向对象之后，该对象不会被垃圾回收器接收直到当前方法结束，才会释放空间。虽然final的引用指向对象A后，不能再重新指向对象B，但是对象内部的值可以修改

package Final;
/*
 final修饰的变量，如果fianl修饰的变量是一个”引用“怎么办？
 final修饰的引用：
    该引用只能指向一个对象，并且它只能永远指向该对象。无法再指向其他对象。
    并且再该方法执行过程中，该引用指向对象之后，该对象不会被垃圾回收器接收
    直到当前方法结束，才会释放空间
虽然final的引用指向对象A后，不能再重新指向对象B，但是对象内部的值可以修改

*/
public class Test02 {
public static void main(String[] args){
P p = new P(20);

    <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span>p<span class="token punctuation">.</span>age<span class="token punctuation">)</span><span class="token punctuation">;</span>
    <span class="token comment">//-------------------------------------</span>
    <span class="token keyword">final</span> <span class="token class-name">P</span> p1 <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">P</span><span class="token punctuation">(</span><span class="token number">30</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
    <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span>p<span class="token punctuation">.</span>age<span class="token punctuation">)</span><span class="token punctuation">;</span>
    p<span class="token punctuation">.</span>age <span class="token operator">=</span> <span class="token number">60</span><span class="token punctuation">;</span>
    <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span>p<span class="token punctuation">.</span>age<span class="token punctuation">)</span><span class="token punctuation">;</span>

    <span class="token comment">//p1 = new P(); 不可以重新new</span>

<span class="token punctuation">}</span>

}
class P{
int age;

<span class="token keyword">public</span> <span class="token class-name">P</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
<span class="token punctuation">}</span>

<span class="token keyword">public</span> <span class="token class-name">P</span><span class="token punctuation">(</span><span class="token keyword">int</span> age<span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
    <span class="token keyword">this</span><span class="token punctuation">.</span>age <span class="token operator">=</span> age<span class="token punctuation">;</span>
<span class="token punctuation">}</span>

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37

9. final修饰的实例变量

​ final修饰的变量只能赋值一次
​ fianl修饰的实例变量，系统不管赋默认值，要求程序员必须手动赋值。这个手动复制，在变量后面直接赋值或者在构造方法中进行赋值也可以。

​ 实例变量在什么时候赋值？
​ 在构造方法执行中进行赋值，（new的时候）

package Final;
/*
final修饰的实例变量
    final修饰的变量只能赋值一次
    fianl修饰的实例变量，系统不管赋默认值，要求程序员必须手动赋值
    这个手动复制，在变量后面直接赋值或者在构造方法中进行赋值也可以。
实例变量在什么时候赋值？
    在构造方法执行中进行赋值，（new的时候）

*/
public class Test03 {
public static void main(String[] args){

<span class="token punctuation">}</span>

}
class User{
//不可以这么修饰变量 final int i;
//手动赋值可以
final int age = 1;
//以下代码需要组合使用 weight只赋值一次
final double weight;
/public User(){
weight = 80;//赶在系统赋默认值之前赋值就行
}/
//这样也可以
public User(double D){
this.weight = D;
}
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29

10. final和static联合修饰的变量-常量（每个单词都大写）

结论：

​ static final 联合修饰的变量称为“常量”。
​ 每一个单词建议使用大写，每个单词之间使用下划线链接
​ 实际上常量和静态变量医用，区别在于：常量值不能变
​ 常量和静态变量，都是存储在方法区，并且都是在类加载时初始化。

​ 常量一般都是公开的，因为公开也不可以改变

package Final;
/*
final修饰的变量一边添加在static修饰

结论：
static final 联合修饰的变量称为“常量”。
每一个单词建议使用大写，每个单词之间使用下划线链接
实际上常量和静态变量医用，区别在于：常量值不能变
常量和静态变量，都是存储在方法区，并且都是在类加载时初始化。
*/
public class Test04 {
public static void main(String[] args){
System.out.println(Chiness.COUNTRY);

<span class="token punctuation">}</span>

}
class Chiness{
String idCard;
String name;
String birth;
//实例变量，在堆中，
//实例变量被final修饰了，说明该实例变量的值不会随着对象的变量而变化
//final修饰的实例变量，一般添加static修饰。
//即使是不会发生改变，最好声明为静态的，节省内存空间
final static String COUNTRY = “China”; //类级别
}
class MyMath{
//常量一般都是公开的
public static final double PI = 3.1415926;

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31

总结

1.1、final修饰的类无法继承。
1.2、final修饰的方法无法覆盖。
1.3、final修饰的变量只能赋一次值。
1.4、final修饰的引用一旦指向某个对象，则不能再重新指向其它对象，但该引用指向的对象内部的数据是可以修改的。
1.5、final修饰的实例变量必须手动初始化，不能采用系统默认值。
1.6、final修饰的实例变量一般和static联合使用，称为常量。
public static final double PI = 3.1415926;

抽象类和接口以及抽象类和接口的区别

抽象类的理解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YVk85nKx-1634041323675)(C:/Users/77/Downloads/Documents/09-JavaSE进阶每章课堂画图/01-面向对象/001-抽象类的理解.png)]

1. 什么是抽象类？

​ 类和类之间具有共同特征，将这些类的共同特征提取出来，形成的就是抽象类
​ 类本身是不存在，所以抽象类无法创建对象

2. 抽象类属于什么类型？

​ 抽象类也属于引用数据类型

3. 抽象类怎么定义？

​    语法：
​	    [修饰符列表] abstract class 类名{
​	    	    类体;
​	    }

 
 

 
 
1
2
3
4

4. 抽象类是无法实例化的，是无法创建对象的，所以抽象类是用来被子类继承的

5. final和abstract是不可以联合使用的

​ 这两个关键字是对立的

6. 抽象类的子类也可以是抽象类

7. 抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的。

8.抽象类关联到一个概念，抽象方法的概念

​ 抽象方法表示没有实现的方法，没有方法体的方法。
​ pubilic abstract void doSome();
​ 抽象方法的特点：
​ 1.没有方法体，以分号结尾；
​ 2.前面修饰符列表中有abstract关键字

9.抽象类中不一定有抽象方法,抽象方法必须在抽象类中

package Abstract;
/*
抽象类：
    1.什么是抽象类？
        类和类之间具有共同特征，将这些类的共同特征提取出来，形成的就是抽象类
        类本身是不存在，所以抽象类无法创建对象
    2.抽象类属于什么类型？
        抽象类也属于引用数据类型
    3.抽象类怎么定义？
        语法：
        [修饰符列表] abstract class 类名{
            类体;
        }
    4.抽象类是无法实例化的，是无法创建对象的，所以抽象类是用来被子类继承的
    5.final和abstract是不可以联合使用的
    6.抽象类的子类也可以是抽象类
    7.抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的。
    8.抽象类关联到一个概念，抽象方法的概念
        抽象方法表示没有实现的方法，没有方法体的方法
        pubilic abstract void doSome();
        抽象方法的特点：
            1.没有方法体，以分号结尾；
            2.前面修饰符列表中有abstract关键字
    9.抽象类中不一定有抽象方法,抽象方法必须在抽象类中
 */
public class Test01 {
    public static void main(String[] args){
        //无法实例化，不可以创建对象
        //Account account = new Account();
    }
}
//final和abstract是不可以联合使用的
/*final abstract class Account{

}*/
abstract class Account{
public Account(String s){

<span class="token punctuation">}</span>
<span class="token comment">//不可以不写</span>
<span class="token keyword">public</span> <span class="token class-name">Account</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
<span class="token punctuation">}</span>
<span class="token keyword">abstract</span> <span class="token keyword">public</span> <span class="token keyword">void</span> <span class="token class-name">A</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>

}
//子类继承抽象类，子类可以实例化对象
/*class CreditAccount extends Account{

}*/
//抽象类的子类可以是抽象类
//构造方法里默认有一个无参构造
//无参构造的第一行为super，super调用父类的无参构造，如果父类没有无参构造（直接提供了一个有参构造，默认没有无参构造），那么会报错
abstract class CreditAccount extends Account{

}
//抽象方法必须在抽象方法中
/*

class B{
abstract public void A();
}*/

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63

10.抽象方法怎么定义？

​ public abstract void doSome();

11.(五颗星）：一个非抽象的类，继承抽象类，必须将抽象类中的抽象方法进行覆盖/重写/实现。

package Abstract;
/*
 抽象类：
    1.抽象类不一定有抽象方法，抽象方法必须出现在抽象类中
    2.重要结论:一个非抽象的类继承抽象类，必须将抽象类中的抽象方法进行实现
这里的覆盖或者说重写，也可以叫做实现

*/
public class Test02 {
//父类型为抽象类，子类型为非抽象类，这里是否可以使用多态
//面向抽象编程
//a的类型Animal，Animal是抽象的，以后调用的都是a.××
// 面向抽象编程，不要面向具体变成，降低程序的耦合度，提高程序的扩展能力
//这种编程思想符合OCP原则
public static void main(String[] args){ //对代码不是很理解的时候，能用多态就用多态
Animal a = new Brid(); //向下转型
a.move();
}
}
//抽象类
abstract class Animal{
public abstract void move();//抽象方法

}
//子类非抽象类
//子类继承父类，父类中有抽象方法，那么子类一定会是抽象类
class Brid extends Animal{
//需要将从父类继承过来的方法进行覆盖/重写，或者也可以叫做“实现”
//把抽象方法实现了
public void move(){
System.out.println(“move”);
};

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34

​ 面试题（判断题）：java语言中凡是没有方法体的方法都是抽象方法。
​ 不对，错误的。
​ Object类中就有很多方法都没有方法体，都是以“;”结尾的，但他们
​ 都不是抽象方法，例如：
​ public native int hashCode();
​ 这个方法底层调用了C++写的动态链接库程序。
​ 前面修饰符列表中没有：abstract。有一个native。表示调用JVM本地程序。

接口

接口的基础语法

1、接口是一种“引用数据类型”。

2、接口是完全抽象的。

3、接口怎么定义：[修饰符列表] interface 接口名{}

4、接口支持多继承。

5、接口中只有常量+抽象方法。

6、接口中所有的元素都是public修饰的

7、接口中抽象方法的public abstract可以省略。

8、接口中常量的public static final可以省略。

9、接口中方法不能有方法体。

package Interface;
/*
接口：
    1.也是一种引用数据类型，编译之后也是class字节码文件
    2.接口是完全抽象的。（抽象类是半抽象的），或者也可以说接口是特殊的抽象类
    3.接口是怎么定定义，语法是什么？
    [修饰符列表] interface 接口名(
    )
    定义类 [修饰符列表] class 类名{}
    定义抽象类 [修饰符列表] abstract class 类名{}
    4.接口支持多继承，一个接口可以继承多个接口
    5.接口中只包含两部分内容，一部分是常量，一部分是抽象方法，接口中没有其他内容
    6.接口中所有的元素都是public修饰的，接口中所有的东西都是公开的
    7.接口中的抽象方法，public abstra 是可以省略的
    8.接口中的方法都是抽象方法，接口中的方法不能有方法体。
    10.接口中常量的public static final 可以省略
 */
public class Test01 {
    public static void main(String[] args){
        // 接口中随便写一个变量就是常量
        System.out.println( MyMath.PI);
<span class="token punctuation">}</span>

}
interface A {

}
interface B{

}
//接口支持多继承
interface C extends A,B{

}
interface MyMath{
//常量
public static final double PI = 3.14;
//可以省略public static final
double K = 3.1;

<span class="token comment">// public abstract int sum(int a, int b);//抽象方法</span>

<span class="token comment">//接口当中都是抽象发放，那么在编写代码的时候，public static'可以省略么？</span>
<span class="token keyword">int</span> <span class="token function">sum</span><span class="token punctuation">(</span><span class="token keyword">int</span> a<span class="token punctuation">,</span> <span class="token keyword">int</span> b<span class="token punctuation">)</span><span class="token punctuation">;</span>

<span class="token comment">//接口中的方法可以有方法体么？</span>
<span class="token comment">//错误：抽象方法不可以带有主体</span>
<span class="token comment">/*void doSome(){

}*/</span>
<span class="token comment">//sub方法</span>
<span class="token keyword">int</span> <span class="token function">sub</span><span class="token punctuation">(</span><span class="token keyword">int</span> a<span class="token punctuation">,</span><span class="token keyword">int</span> b<span class="token punctuation">)</span><span class="token punctuation">;</span>

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54

10.类和类之间叫做继承，类和接口之间叫做实现，仍然可以将实现看作继承，继承使用extends，实现使用implements

11.当一个非抽象的类实现接口的话，必须将接口中所有的抽象方法全部实现。

package Interface;
/*
接口：
    1.类和类之间叫做继承，类和接口之间叫做实现，仍然可以将实现看作继承，继承使用extends，实现使用implements
    2.当一个非抽象的类实现接口的话，必须将接口中所有的抽象方法全部实现。
 */
public class Test02 {
    public static void main(String[] args){
        //接口使用多态
        MyMath2 mm = new Ab();
        System.out.println(mm.PI);
        int re = mm.sub(4,3);
        System.out.println(re);
<span class="token punctuation">}</span>

}
interface MyMath2{

<span class="token keyword">public</span> <span class="token keyword">static</span> <span class="token keyword">final</span> <span class="token keyword">double</span> PI <span class="token operator">=</span> <span class="token number">3.14</span><span class="token punctuation">;</span>

<span class="token keyword">int</span> <span class="token function">sum</span><span class="token punctuation">(</span><span class="token keyword">int</span> a<span class="token punctuation">,</span> <span class="token keyword">int</span> b<span class="token punctuation">)</span><span class="token punctuation">;</span>

<span class="token keyword">int</span> <span class="token function">sub</span><span class="token punctuation">(</span><span class="token keyword">int</span> a<span class="token punctuation">,</span><span class="token keyword">int</span> b<span class="token punctuation">)</span><span class="token punctuation">;</span>

}
//编写一个类(这个类是非抽象类)
//需要重写方法，因为Ab不是抽象类
class Ab implements MyMath2{
//实现接口中的方法
public int sum(int a, int b){

    <span class="token keyword">return</span> a<span class="token operator">+</span>b<span class="token punctuation">;</span>
<span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token keyword">public</span> <span class="token keyword">int</span> <span class="token function">sub</span><span class="token punctuation">(</span><span class="token keyword">int</span> a<span class="token punctuation">,</span> <span class="token keyword">int</span> b<span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
    <span class="token keyword">return</span> a<span class="token operator">-</span>b<span class="token punctuation">;</span>
<span class="token punctuation">}</span><span class="token punctuation">;</span>

}
//抽象类实现，可以编译通过
abstract class Ac implements MyMath2{

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42

12.一个类可以实现多个接口

接口和接口之间虽然后没有继承关系，但是可以强制转换，但是运行时可能会出现ClassCastException异常，需要于类和类之间的强制转换一样，加上instanceof判断。

package Interface;
/*
    一个类可以同时实现多个接口
        java中的类和类之间只允许单继承，实际上单继承是为了简单出现的
        很多情况下会存在多继承，接口弥补了这个缺陷
    接口A和接口B虽然没有继承关系，但是可以互相强制转换，但是运行时可能出现ClassCastException异常

    无论是向下转型还是向上转向，都必须要有继承关系
    没有继承关系，编译器会报错（接口不会）
    都需要加上instanceof进行判断，转型之前先进行判断。

*/
public class Test03 {
public static void main(String[] args){
//多态
AA a = new D();
BB b = new D();
//向下转型
BB b1 = (BB)a;
b1.m2();
//向下转型直接转成D
D d = (D) a;
d.m2();

    <span class="token class-name">M</span> m <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">E</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>

    <span class="token comment">//经过测试，接口和接口郑伊健在进行强制类型转换的时候，没有继承关系，也可以强转</span>
    <span class="token comment">//但是运行时可能会出现ClassCastException异常，编译没问题，运行有问题</span>
    <span class="token keyword">if</span><span class="token punctuation">(</span>m <span class="token keyword">instanceof</span> <span class="token class-name">K</span><span class="token punctuation">)</span>
    <span class="token punctuation">{<!-- --></span>
        <span class="token class-name">K</span> k <span class="token operator">=</span> <span class="token punctuation">(</span><span class="token class-name">K</span><span class="token punctuation">)</span>m<span class="token punctuation">;</span>
    <span class="token punctuation">}</span>

<span class="token punctuation">}</span>

}
interface M{

}
interface K{

}
class E implements M,K{

}
interface AA{
void m1();
}
interface BB{
void m2();
}
interface CC{
void m3();
}
//类和接口之间可以进行多实现
//需要对接口中的类进行重写
//类似于多继承
class D implements AA,BB,CC{
//实现A接口的m1
public void m1(){ };
public void m2(){ };
public void m3(){ };
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62

13.继承和实现都存在的话:extends关键字在前，implements关键字在后。

package Interface;
/*
继承和实现都存在的话:extends关键字在前，implements关键字在后。
 */
public class Test04 {
    public static void main(String[] args){
        //创建对象
        Flyable f = new Cats();//多态
        f.fly();
        Flyable f1 = new fish();
        f1.fly();
<span class="token punctuation">}</span>

}
class Animal{

}
interface Flyable{
void fly();
}
class Cats extends Animal implements Flyable{
@Override
//重写接口的抽象方法
public void fly() {
System.out.println(“飞猫”);
}
}
//没有实现接口
class Snake extends Animal{

}
class fish extends Animal implements Flyable{
public void fly() {
System.out.println(“飞🐟”);
}
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36

14.使用接口，写代码的时候，可以使用多态（父类型引用指向子类型对象）。

接口在开发中的作用

接口在开发中的作用，类似于多态在开发中的作用。

多态：面向抽象编程，不要面向具体编程，提高程序的扩展力，降低程序的耦合度。

/*
			public class Master{
				public void feed(Dog d){}
				public void feed(Cat c){}
				//假设又要养其它的宠物，那么这个时候需要再加1个方法。（需要修改代码了）
				//这样扩展力太差了，违背了OCP原则（对扩展开放，对修改关闭。）
			}
	*/

 
 

 
 
1
2
3
4
5
6
7
8

		public class Master{
			public void feed(Animal a){
				// 面向Animal父类编程，父类是比子类更抽象的。
				//所以我们叫做面向抽象编程，不要面向具体编程。
				//这样程序的扩展力就强。
			}
		}

 
 

 
 
1
2
3
4
5
6
7

接口在开发中的作用：

​ 接口是完全抽象的，以后面向抽象编程可以改为：面向接口编程

​ 有了接口，就代表扩展里很强，这是高扩展性，低耦合度。

​ 接口在现实世界中是不是到处都是呢？
​ 螺栓和螺母之间有接口
​ 灯泡和灯口之间有接口
​ 笔记本电脑和键盘之间有接口（usb接口，usb接口是不是某个计算机协会制定的协议/规范。）
​ 接口有什么用？扩展性好。可插拔。
​ 接口是一个抽象的概念。

总结：面向接口编程，可以降低程序的耦合度，提高程序的扩展力。符合OCP开发原则。
接口的使用离不开多态机制。（接口+多态才可以达到降低耦合度。）

​ 接口可以解耦合，解开的是谁和谁的耦合！！！
​ 任何一个接口都有调用者和实现者。
​ 接口可以将调用者和实现者解耦合。
​ 调用者面向接口调用。
​ 实现者面向接口编写实现。

​ 以后进行大项目的开发，一般都是将项目分离成一个模块一个模块的，
​ 模块和模块之间采用接口衔接。降低耦合度。

is a 、has a、like a

is a：

​ Cat is a animal

​ 凡是能满足is a 都是表示“继承关系”

has a：

​ Student has a pen

​ 凡是能够满足has a 都表示“关联关系”，关联关系通常以“属性”的形式存在

​A{
​	B b;
​}

 
 

 
 
1
2
3

like a：

​ Cooker like a menu

​ 凡是满足like a 表示”实现关系“，实现关系通常是：类实现接口

​ A implements B

抽象类和接口有什么区别？

抽象类是半抽象的，接口是完全抽象的；

抽象类有构造方法，接口中没有构造方法；

接口和接口支持多继承，抽象类之间只能单继承；

一个类可以同时实现接口，一个抽象类只能继承一个类；

接口中只允许出现在常量和抽象方法；

​ 以后接口使用的比抽象类多。一般抽象类使用的还是少。
​ 接口一般都是对“行为”的抽象。

package 和 import

package

1. package是Java中的包机制，包机制的作用是为了方便程序的关系

不同功能的类分别存放在不同的包下。（按照功能的划分，不同的软件包具有不同的功能。）

2. package是一个关键字。例如：

package demo.src.packageandimport;package语句只允许出现在源代码的第一行

3. 包名的命名规范：一般都采用公司域名倒序的方式（公司的域名具有全球唯一性）

​ 包名的命名规范：
​ 公司域名倒序 + 项目名 + 模块名+ 功能名

4. 带有包名怎么编译？

javac -d . xxx.java

5. 怎么运行？

java 完整类名

​ 补充：以后说类名的时候，如果带着包名描述，表示完整类名。
​ 如果没有带包，描述的话，表示简类名。
​ java.util.Scanner 完整类名。
​ Scanner 简类名

import

1. import什么时候不需要？

​ java.lang不需要。
​ 同包下不需要。
​ 其它一律都需要。

2. 怎么用？

​ import 完整类名;
​ import 包名.*;

​ import java.util.Scanner; // 完整类名。

​ // 同学的疑问：这样是不是效率比较低。
​ // 这个效率不低，因为编译器在编译的时候，会自动把*变成具体的类名。
​ import java.util. * ;

​ // 想省懒劲你不能太省了。
​ import java.* ; 这是不允许的，因为在java语言中规定，这里的*只代表某些类的名字。

访问控制权限

访问控制权限的种类

private 私有的 只能在本类中访问

public 公开的 在任何位置都能访问

protected 受保护的 表示只能在本类、同包以及子类中访问

​ 默认的 表示只能在本类以及同包下访问

修饰符列表 本类 同包 子类 任意位置

public 可以 可以 可以 可以

protected 可以 可以 可以

默认 可以 可以

private 可以

范围从大到小排序：public > protected > 默认 > private

访问控制权限修饰符可以修饰什么？

属性 4个都能用

方法 4个都能用

类 public和默认

接口 public和默认

JDK类库的根类：Object

1.Object类中的方法

这个类中的方法都是所有子类通用的，任何一个类都是默认继承Object，就算没有直接继承，最终也会间接继承

Object类中常用的方法

第一种方法：去源代码当中。（比较麻烦）

第二种方法：去查阅Java的帮助文档

什么是API？

API是应用程序编程接口，整个JDK的类库就是一个javase的API，每一个API都会配置一套API帮助文档。SUN公司提前写好的类库叫做API

目前为止我们只需要知道：

protected Object clone()

//负责对象克隆

int hashcode()

// 获取对象的哈希值的一个方法

在Object中hashcode的方法的源码
public native int hashcode();
这个方法不是抽象方法，带有native关键字，底层调用c++程序

​ hashchode()返回哈希值，实际上就是一个Java对象的内存地址，经过哈希算法，得出的一个值
​ 所以hashcode()方法的执行结果可以等同看作是一个Java对象的内存地址。

package ObjectJDK;
/*
hashcode方法
    1. 在Object中hashcode的方法的源码
        public native int hashcode();
        这个方法不是抽象方法，带有native关键字，底层调用c++程序
    hashchode()返回哈希值，实际上就是一个Java对象的内存地址，经过哈希算法，得出的一个值
    所以hashcode()方法的执行结果可以等同看作是一个Java对象的内存地址。

*/
public class Test07 {
public static void main(String[] args){
Object o = new Object();
int hashCodeValue = o.hashCode();

    <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span>hashCodeValue<span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment">//295530567</span>

    <span class="token class-name">Myclass</span> myclass <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">Myclass</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
    <span class="token keyword">int</span> hashCodeValue2 <span class="token operator">=</span> myclass<span class="token punctuation">.</span><span class="token function">hashCode</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
    <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span>hashCodeValue2<span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment">//1324119927</span>

<span class="token punctuation">}</span>

}
class Myclass{

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27

boolean euqals(Object obj)

// 判断对象是否相等

以后所有类的equals方法也需要重写，因为Object中的equals方法比较的是两个对象的内存地址，我们应该比较内容，所以需要重写。

​ 重写规则：自己定，主要看是什么和什么相等时表示两个对象相等。

​ 基本数据类型比较实用：==
​ 对象和对象比较：调用equals方法

​ String类是SUN编写的，所以String类的equals方法重写了。
​ 以后判断两个字符串是否相等，最好不要使用==，要调用字符串对象的equals方法。

​ 注意：重写equals方法的时候要彻底。

总结：
1.String类已经重写了equals方法；
2.String类已经重写了toString方法；

java中基本数据类型比较是否相等使用”==“

java中引用数据类型使用equals方法来判断相等

package ObjectJDK;
/*
 关于euqals方法
 1.源代码
    public boolean equals(Object obj) {
        return (this == obj);
    }
    以上这个方法是Object的类默认实现
    在Object中equals方法当中，默认使用的是==“判断两个对象是否相等，而”==“判断的是两个Java对象的内存地址，我们应该判断两个Java对象的内容是否相等
2.SUN公司设计equals方法的目的：
    以后的编程过程中，要通过equals方法来判断两个对象是否相等。
3.判断两个Java对象不能使用“==”，“==”判断的是两个对象的内存地址

*/
public class Test02 {
public static void main(String[] args){
//判断两个基本数据类型的数据是否相等，可以直接使用“”
// == 是判断a中的100和b中的100是否相等，保存的是a、b中的变量
int a = 100;
int b = 100;
System.out.println(a b); //true
//判断两个java对象是否相等 使用equals
MyTime t1 = new MyTime(2008,8,8);//内存地址1
MyTime t2 = new MyTime(2008,8,8);//内存地址2
//测试一下，两个对象的相等可以不可以使用双等号
//这里的双等号判断的是：t1中保存的对象内存地址和t2中保存的对象内存地址是否相等
//System.out.println(t1 == t2);
boolean B = t1.equals(t2);
System.out.println(B);

    <span class="token class-name">MyTime</span> t3 <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">MyTime</span><span class="token punctuation">(</span><span class="token number">2008</span><span class="token punctuation">,</span><span class="token number">8</span><span class="token punctuation">,</span><span class="token number">9</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
    <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span>t1<span class="token punctuation">.</span><span class="token function">equals</span><span class="token punctuation">(</span>t3<span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>

    <span class="token class-name">MyTime</span> t4 <span class="token operator">=</span> <span class="token keyword">null</span><span class="token punctuation">;</span>
    <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span>t1<span class="token punctuation">.</span><span class="token function">equals</span><span class="token punctuation">(</span>t4<span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>

}
class MyTime{
private int year;
private int month;
private int day;

<span class="token keyword">public</span> <span class="token class-name">MyTime</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
<span class="token punctuation">}</span>

<span class="token keyword">public</span> <span class="token class-name">MyTime</span><span class="token punctuation">(</span><span class="token keyword">int</span> year<span class="token punctuation">,</span> <span class="token keyword">int</span> month<span class="token punctuation">,</span> <span class="token keyword">int</span> day<span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>

    <span class="token keyword">this</span><span class="token punctuation">.</span>year <span class="token operator">=</span> year<span class="token punctuation">;</span>
    <span class="token keyword">this</span><span class="token punctuation">.</span>month <span class="token operator">=</span> month<span class="token punctuation">;</span>
    <span class="token keyword">this</span><span class="token punctuation">.</span>day <span class="token operator">=</span> day<span class="token punctuation">;</span>
<span class="token punctuation">}</span>

<span class="token keyword">public</span> <span class="token keyword">int</span> <span class="token function">getYear</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
    <span class="token keyword">return</span> year<span class="token punctuation">;</span>
<span class="token punctuation">}</span>

<span class="token keyword">public</span> <span class="token keyword">int</span> <span class="token function">getMonth</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
    <span class="token keyword">return</span> month<span class="token punctuation">;</span>
<span class="token punctuation">}</span>

<span class="token keyword">public</span> <span class="token keyword">int</span> <span class="token function">getDay</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
    <span class="token keyword">return</span> day<span class="token punctuation">;</span>
<span class="token punctuation">}</span>

<span class="token keyword">public</span> <span class="token keyword">void</span> <span class="token function">setYear</span><span class="token punctuation">(</span><span class="token keyword">int</span> year<span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
    <span class="token keyword">this</span><span class="token punctuation">.</span>year <span class="token operator">=</span> year<span class="token punctuation">;</span>
<span class="token punctuation">}</span>

<span class="token keyword">public</span> <span class="token keyword">void</span> <span class="token function">setMonth</span><span class="token punctuation">(</span><span class="token keyword">int</span> month<span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
    <span class="token keyword">this</span><span class="token punctuation">.</span>month <span class="token operator">=</span> month<span class="token punctuation">;</span>
<span class="token punctuation">}</span>

<span class="token keyword">public</span> <span class="token keyword">void</span> <span class="token function">setDay</span><span class="token punctuation">(</span><span class="token keyword">int</span> day<span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
    <span class="token keyword">this</span><span class="token punctuation">.</span>day <span class="token operator">=</span> day<span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token comment">/*
    要重写toString方法，越简洁越好，可读性越强越好
    向简洁的、详实的、易读方法发展
 */</span>

/* public String toString(){
return year + “年” + month + “月” + day + “日”;

}*/</span>

<span class="token comment">/*
默认的equals
public boolean equals(Object obj) {
    return (this == obj);
}
 */</span>
<span class="token comment">//重写equals方法</span>
<span class="token comment">/*public boolean equals(Object obj) {
    if (obj instanceof MyTime) {
        MyTime mt = (MyTime) obj;
        if (this.year == mt.year &amp;&amp; this.month == mt.month &amp;&amp; this.day == mt.day) {
            return true;
        }
    }
    return false;
}*/</span>
<span class="token comment">//改良equals方法</span>
<span class="token comment">/*public boolean equals(Object obj){
    //如果是空
    if(obj == null){
        return false;
    }//如果不是MyTime
    if(!(obj instanceof MyTime)){
        return false;
    }//如果内存地址相同 比如 t1.equals(t1)
    if (this == obj){
        return true;
    }
    MyTime mt = (MyTime) obj;
    if (this.year == mt.year &amp;&amp; this.month == mt.month &amp;&amp; this.day == mt.day) {
        return true;
    }
    //执行到此，说明obj不是null，obj是MyTime
    return false;
}*/</span>
<span class="token comment">//再次改良</span>
<span class="token keyword">public</span> <span class="token keyword">boolean</span> <span class="token function">equals</span><span class="token punctuation">(</span><span class="token class-name">Object</span> obj<span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
    <span class="token comment">//如果是空</span>
    <span class="token keyword">if</span><span class="token punctuation">(</span>obj <span class="token operator">==</span> <span class="token keyword">null</span> <span class="token operator">||</span> <span class="token operator">!</span><span class="token punctuation">(</span>obj <span class="token keyword">instanceof</span> <span class="token class-name">MyTime</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
        <span class="token keyword">return</span> <span class="token boolean">false</span><span class="token punctuation">;</span>
    <span class="token punctuation">}</span><span class="token comment">//如果不是MyTime</span>
    <span class="token comment">//如果内存地址相同 比如 t1.equals(t1)</span>
    <span class="token keyword">if</span> <span class="token punctuation">(</span><span class="token keyword">this</span> <span class="token operator">==</span> obj<span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
        <span class="token keyword">return</span> <span class="token boolean">true</span><span class="token punctuation">;</span>
    <span class="token punctuation">}</span>
    <span class="token class-name">MyTime</span> mt <span class="token operator">=</span> <span class="token punctuation">(</span><span class="token class-name">MyTime</span><span class="token punctuation">)</span> obj<span class="token punctuation">;</span>
    <span class="token keyword">return</span> <span class="token keyword">this</span><span class="token punctuation">.</span>year <span class="token operator">==</span> mt<span class="token punctuation">.</span>year <span class="token operator">&amp;&amp;</span> <span class="token keyword">this</span><span class="token punctuation">.</span>month <span class="token operator">==</span> mt<span class="token punctuation">.</span>month <span class="token operator">&amp;&amp;</span> <span class="token keyword">this</span><span class="token punctuation">.</span>day <span class="token operator">==</span> mt<span class="token punctuation">.</span>day<span class="token punctuation">;</span>
<span class="token punctuation">}</span>

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84
• 85
• 86
• 87
• 88
• 89
• 90
• 91
• 92
• 93
• 94
• 95
• 96
• 97
• 98
• 99
• 100
• 101
• 102
• 103
• 104
• 105
• 106
• 107
• 108
• 109
• 110
• 111
• 112
• 113
• 114
• 115
• 116
• 117
• 118
• 119
• 120
• 121
• 122
• 123
• 124
• 125
• 126
• 127
• 128
• 129
• 130
• 131
• 132

package ObjectJDK;
/*
    java重写了toString和equals方法
总结：
    1.String类已经重写了equals方法；
    2.String类已经重写了toString方法；

  java中基本数据类型比较是否相等使用”==“
  java中引用数据类型使用equals方法来判断相等

*/
public class Test03 {
public static void main(String[] args){
//大部分情况下，我们采用这样的方式来创建字符串对象
String s1 = “Hello”;
String s2 = “ABC”;
//实际上String属于一个类，不属于基本数据类型
//既然String是一个类，那么存在基本构造方法
String s3 = new String(“test1”);//内存地址是不同的
String s4 = new String(“test1”);

    <span class="token comment">//String类已经重写equals方法</span>
    <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span>s3<span class="token punctuation">.</span><span class="token function">equals</span><span class="token punctuation">(</span>s4<span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
    <span class="token comment">//String已经重写了toString方法</span>
    <span class="token class-name">String</span> x <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">String</span><span class="token punctuation">(</span><span class="token string">"xx"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
    <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span>x<span class="token punctuation">.</span><span class="token function">toString</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28

package ObjectJDK;

public class Test05 {
public static void main(String[] args){
Address a1 = new Address(“1”,“2”,“3”);
User u1 = new User(“yx”,a1);
User u2 = new User(“yx”,a1);
User u3 = new User(“yy”,new Address(“1”,“2”,“1”));
System.out.println(u1.addr);
boolean flag = u1.equals(u2);
System.out.println(flag);
System.out.println(u1.equals(u3));
}
}
class User{
String name;
Address addr;

<span class="token keyword">public</span> <span class="token class-name">User</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
<span class="token punctuation">}</span>

<span class="token keyword">public</span> <span class="token class-name">User</span><span class="token punctuation">(</span><span class="token class-name">String</span> name<span class="token punctuation">,</span> <span class="token class-name">Address</span> addr<span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
    <span class="token keyword">this</span><span class="token punctuation">.</span>name <span class="token operator">=</span> name<span class="token punctuation">;</span>
    <span class="token keyword">this</span><span class="token punctuation">.</span>addr <span class="token operator">=</span> addr<span class="token punctuation">;</span>
<span class="token punctuation">}</span>

<span class="token keyword">public</span> <span class="token keyword">boolean</span> <span class="token function">equals</span><span class="token punctuation">(</span><span class="token class-name">Object</span> obj<span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
    <span class="token keyword">if</span><span class="token punctuation">(</span>obj <span class="token operator">==</span> <span class="token keyword">null</span> <span class="token operator">||</span> <span class="token operator">!</span><span class="token punctuation">(</span>obj <span class="token keyword">instanceof</span> <span class="token class-name">User</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
        <span class="token keyword">return</span> <span class="token boolean">false</span><span class="token punctuation">;</span>
    <span class="token punctuation">}</span>
    <span class="token keyword">if</span> <span class="token punctuation">(</span><span class="token keyword">this</span> <span class="token operator">==</span> obj<span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
        <span class="token keyword">return</span> <span class="token boolean">true</span><span class="token punctuation">;</span>
    <span class="token punctuation">}</span>
    <span class="token class-name">User</span> u <span class="token operator">=</span> <span class="token punctuation">(</span><span class="token class-name">User</span><span class="token punctuation">)</span>obj<span class="token punctuation">;</span>
    <span class="token keyword">if</span><span class="token punctuation">(</span><span class="token keyword">this</span><span class="token punctuation">.</span>addr<span class="token punctuation">.</span><span class="token function">equals</span><span class="token punctuation">(</span>u<span class="token punctuation">.</span>addr<span class="token punctuation">)</span> <span class="token operator">&amp;&amp;</span> <span class="token keyword">this</span><span class="token punctuation">.</span>name<span class="token punctuation">.</span><span class="token function">equals</span><span class="token punctuation">(</span>u<span class="token punctuation">.</span>name<span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
        <span class="token keyword">return</span> <span class="token boolean">true</span><span class="token punctuation">;</span>
    <span class="token punctuation">}</span>
    <span class="token keyword">return</span> <span class="token boolean">false</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>

}
class Address{
String city;
String street;
String zipcode;

<span class="token keyword">public</span> <span class="token class-name">Address</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
<span class="token punctuation">}</span>

<span class="token keyword">public</span> <span class="token class-name">Address</span><span class="token punctuation">(</span><span class="token class-name">String</span> city<span class="token punctuation">,</span> <span class="token class-name">String</span> street<span class="token punctuation">,</span> <span class="token class-name">String</span> zipcode<span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
    <span class="token keyword">this</span><span class="token punctuation">.</span>city <span class="token operator">=</span> city<span class="token punctuation">;</span>
    <span class="token keyword">this</span><span class="token punctuation">.</span>street <span class="token operator">=</span> street<span class="token punctuation">;</span>
    <span class="token keyword">this</span><span class="token punctuation">.</span>zipcode <span class="token operator">=</span> zipcode<span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token keyword">public</span> <span class="token class-name">String</span> <span class="token function">toString</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
    <span class="token keyword">return</span> <span class="token string">"CITY:"</span> <span class="token operator">+</span> city <span class="token operator">+</span> <span class="token string">",STREET:"</span> <span class="token operator">+</span> street <span class="token operator">+</span> <span class="token string">",ZIPCODE:"</span> <span class="token operator">+</span> zipcode<span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token keyword">public</span> <span class="token keyword">boolean</span> <span class="token function">equals</span><span class="token punctuation">(</span><span class="token class-name">Object</span> obj<span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
    <span class="token keyword">if</span><span class="token punctuation">(</span>obj <span class="token operator">==</span> <span class="token keyword">null</span> <span class="token operator">||</span> <span class="token operator">!</span><span class="token punctuation">(</span>obj <span class="token keyword">instanceof</span> <span class="token class-name">Address</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
        <span class="token keyword">return</span> <span class="token boolean">false</span><span class="token punctuation">;</span>
    <span class="token punctuation">}</span>
    <span class="token keyword">if</span> <span class="token punctuation">(</span><span class="token keyword">this</span> <span class="token operator">==</span> obj<span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
        <span class="token keyword">return</span> <span class="token boolean">true</span><span class="token punctuation">;</span>
    <span class="token punctuation">}</span>
    <span class="token class-name">Address</span> <span class="token class-name">A</span> <span class="token operator">=</span> <span class="token punctuation">(</span><span class="token class-name">Address</span><span class="token punctuation">)</span> obj<span class="token punctuation">;</span>
    <span class="token keyword">if</span><span class="token punctuation">(</span><span class="token keyword">this</span><span class="token punctuation">.</span>city<span class="token punctuation">.</span><span class="token function">equals</span><span class="token punctuation">(</span><span class="token class-name">A</span><span class="token punctuation">.</span>city<span class="token punctuation">)</span> <span class="token operator">&amp;&amp;</span> <span class="token keyword">this</span><span class="token punctuation">.</span>street<span class="token punctuation">.</span><span class="token function">equals</span><span class="token punctuation">(</span><span class="token class-name">A</span><span class="token punctuation">.</span>street<span class="token punctuation">)</span> <span class="token operator">&amp;&amp;</span> <span class="token keyword">this</span><span class="token punctuation">.</span>zipcode<span class="token punctuation">.</span><span class="token function">equals</span><span class="token punctuation">(</span><span class="token class-name">A</span><span class="token punctuation">.</span>zipcode<span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
        <span class="token keyword">return</span> <span class="token boolean">true</span><span class="token punctuation">;</span>
    <span class="token punctuation">}</span>
    <span class="token keyword">return</span> <span class="token boolean">false</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71

String toString()

以后所有类的toString()方法是需要重写的。
重写规则，越简单越明了就好。

​ System.out.println(引用); 这里会自动调用“引用”的toString()方法。

​ String类是SUN写的，toString方法已经重写了。

package ObjectJDK;
/*
关于Object类中的toSting（）方法
    1. 源代码、
     public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
    源代码上toString方法的默认实现为： 类名@对象的内存地址转换为十六进制的形式
    2.SUN公司设计toString方法的作用
        toString方法的设计目的是：通过调用这个方法可以将Java对象转换成字符串的表达形式
    3.其实SUN公司开发java语言的时候，建议所有的子类都去重写toString方法
        toString方法应该是一个简洁的、详实的、易阅读的
 */
public class Test01 {
    public static void main(String[] args){
        MyTime t = new MyTime(1970,1,1);
        String s = t.toString();
        //注意输出引用的时候，会自动调用toString方法
        System.out.println(s);//ObjectJDK.MyTime@776ec8df //1970年1月1日
<span class="token punctuation">}</span>

2

}
class MyTime{
int year;
int month;
int day;

<span class="token keyword">public</span> <span class="token class-name">MyTime</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
<span class="token punctuation">}</span>

<span class="token keyword">public</span> <span class="token class-name">MyTime</span><span class="token punctuation">(</span><span class="token keyword">int</span> year<span class="token punctuation">,</span> <span class="token keyword">int</span> month<span class="token punctuation">,</span> <span class="token keyword">int</span> day<span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>

    <span class="token keyword">this</span><span class="token punctuation">.</span>year <span class="token operator">=</span> year<span class="token punctuation">;</span>
    <span class="token keyword">this</span><span class="token punctuation">.</span>month <span class="token operator">=</span> month<span class="token punctuation">;</span>
    <span class="token keyword">this</span><span class="token punctuation">.</span>day <span class="token operator">=</span> day<span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token comment">/*
    要重写toString方法，越简洁越好，可读性越强越好
    向简洁的、详实的、易读方法发展
 */</span>
<span class="token keyword">public</span> <span class="token class-name">String</span> <span class="token function">toString</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
    <span class="token keyword">return</span>  year <span class="token operator">+</span> <span class="token string">"年"</span> <span class="token operator">+</span> month <span class="token operator">+</span> <span class="token string">"月"</span> <span class="token operator">+</span> day <span class="token operator">+</span> <span class="token string">"日"</span><span class="token punctuation">;</span>

<span class="token punctuation">}</span>

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47

protected void finalize()

//垃圾回收器负责调用的方法

finalize方法

1. 源码
   protected void finalize() throws Throwable { }
2. finalize方法只有一个方法体，里面没有代码，而且这个方法是protected修饰的
3. 这个方法不需要程序员手动调用。责JVM的垃圾回收器负调用这个方法（GC），equals toString方法是手动调用的
4. finalize方法的转型时机：
   当一个Java对象即将呗垃圾回收器回收的时候，垃圾回收器负责调用finalize()方法
5. finalize方法实际上是SUN公司为Java程序员准备的一个时机，垃圾销毁时机，如果希望在对象销毁时机，执行一段代码的话，
   这个代码需要写到finalize
   6. 静态代码块的作用
   static{
   …
   }
   静态代码块在类加载时执行，并执行一次
   这是SUN准备的类加载时机
   finalize()方法也是SUN为程序员准备的一个时机，这个时机就是垃圾回收时机。
   7. Java中的垃圾回收器不会轻易启动。
   垃圾太少，或者时间没到，种种条件下，有可能启动有可能也不启动。

package ObjectJDK;
/*
 finalize方法
    1. 源码
    protected void finalize() throws Throwable { }
    2. finalize方法只有一个方法体，里面没有代码，而且这个方法是protected修饰的
    3. 这个方法不需要程序员手动调用。责JVM的垃圾回收器负调用这个方法（GC），equals toString方法是手动调用的
    4. finalize方法的转型时机：
        当一个Java对象即将呗垃圾回收器回收的时候，垃圾回收器负责调用finalize()方法
    5. finalize方法实际上是SUN公司为Java程序员准备的一个时机，垃圾销毁时机，如果希望在对象销毁时机，执行一段代码的话，
       这个代码需要写到finalize中
    6.静态代码块的作用
        static{
         ....
        }
        静态代码块在类加载时执行，并执行一次
        这是SUN准备的类加载时机
        finalize()方法也是SUN为程序员准备的一个时机，这个时机就是垃圾回收时机。
    7. Java中的垃圾回收器不会轻易启动。
        垃圾太少，或者时间没到，种种条件下，有可能启动有可能也不启动。
 */
public class Test06 {
    public static void main(String[] args){
        Person p = new Person();
        //变成垃圾
        p = null;
    //有一段代码可以建议垃圾回收器启动
    System.gc();
}

}
//项目开发中有这样的业务需求：所有对象在JVM中被释放的时候，请记录一下释放时间
//记录对象被释放的时间点代码写到finalize方法中。
class Person{
protected void finalize() throws Throwable {
System.out.println(“即将被销毁”);
}

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39

内部类

匿名内部类

1. 内部类

内部类：在类的内部又定义了一个新的类，被称为内部类

2. 内部类的分类：

静态内部类：类似于静态变量
实例内部类：类似于实例变量
局部内部类：类似于局部变量

3. 使用内部类编写的代码，可读性很差，能不用尽量不用

4. 匿名内部类属于局部内部类的一种，因为这个类没有名字，而叫匿名内部类

5. 学习匿名内部类的主要目的是让大家以后阅读代码时可以理解。

不建议使用，的两个缺点：
太复杂，可读性差
类没有名字，只能使用一次

package neibulei;
/*
匿名内部类：
    1. 内部类
        内部类：在类的内部又定义了一个新的类，被称为内部类
    2. 内部类的分类：
        静态内部类：类似于静态变量
        实例内部类：类似于实例变量
        局部内部类：类似于局部变量
3. 使用内部类编写的代码，可读性很差，能不用尽量不用
4. 匿名内部类属于局部内部类的一种，因为这个类没有名字，而叫匿名内部类
5. 学习匿名内部类的主要目的是让大家以后阅读代码时可以理解。
    不建议使用，的两个缺点：
        太复杂，可读性差
        类没有名字，只能使用一次

*/
public class Test01 {
public static void main(String[] args){
//调用MyMath中的sum方法
MyMath mm = new MyMath();
// Compute c = new ComputeIm(); 向下转型
//mm.sum(new ComputeIm(),100,200);
mm.sum(new Compute(){
//匿名内部类 不建议使用，代码可读性太差，且只能使用一次。
public int sum(int a, int b) {
return a + b;
}//代表对接口的实现

    <span class="token punctuation">}</span><span class="token punctuation">,</span><span class="token number">100</span><span class="token punctuation">,</span><span class="token number">200</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token keyword">static</span> <span class="token class-name">String</span> country<span class="token punctuation">;</span>
<span class="token comment">//该类在类的内部，所以称为内部类</span>
<span class="token comment">//由于前面有static，所以称为静态内部类</span>
<span class="token keyword">static</span> <span class="token keyword">class</span> <span class="token class-name">Inner1</span><span class="token punctuation">{<!-- --></span>

<span class="token punctuation">}</span>
<span class="token comment">//实例内部类</span>
<span class="token keyword">class</span> <span class="token class-name">Inner2</span><span class="token punctuation">{<!-- --></span>

<span class="token punctuation">}</span>
<span class="token keyword">public</span> <span class="token keyword">void</span> <span class="token function">doSome</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
    <span class="token comment">//局部变量</span>
    <span class="token keyword">int</span> n <span class="token operator">=</span> <span class="token number">100</span><span class="token punctuation">;</span>
    <span class="token comment">//局部内部类</span>
    <span class="token keyword">class</span> <span class="token class-name">Inner3</span><span class="token punctuation">{<!-- --></span>

    <span class="token punctuation">}</span>
<span class="token punctuation">}</span>
<span class="token keyword">public</span> <span class="token keyword">void</span> <span class="token function">doOther</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
    <span class="token comment">//dosome中的局部内部类在这里不能用 不在一个局部区域</span>
<span class="token punctuation">}</span>

}
//接口的实现类
//接口是完全抽象的，方法也是抽象方法，这里要重写方法
/*使用匿名内部类这个实现类可以不写
class ComputeIm implements Compute{

@Override
public int sum(int a, int b) {
    return a + b;
}

}*/
//计算接口
interface Compute {
int sum(int a, int b);
}
class MyMath{
public void sum(Compute c,int x, int y){
int revalue = c.sum(x,y);
System.out.println(x + " + “ + y + ” = " + revalue);
}
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73

数组

一维数组

1.Java中的数组是一种引用数据类型，不属于基本数据类型，数组的父类时Object
2.数组实际上是一个容器，可以容纳多个元素。数组字面意思：一组数据
3.数组当中可以存储基本数据类型的数据，也可以存储引用数据类型的数据
4.数组因为是引用类型，所以数组对象是存储在堆内存中的
Person p1 = new Person();
Person p2 = new Person();
5.数组在内存方面：数组当中如果存储的是”java对象“的话，实际上存储的是对象的”引用(内存地址)“
6.数组一旦创建，在java中规定长度不可变

7.数组的分类：一维、二维、三维、多维…
8.所有的数组对象都有length属性，用来获取数组中元素的个数
9.java中的数组要求数组中的元素类型统一。比如：int类型数组只能存储int，person类型只能存储person
10.数组在内存方面存储的时候，数组中的元素内存地址是连续的（存储的每一个元素都是有规则的挨着排列的），内存地址连续
这是数组的存储特点，实际上数组是一种简单的数据结构
11.所有的数组都是拿”第一个小方块的内存地址“作为第一个内存地址(数组中的首元素内存地址，作为数组的内存地址)

12.数组每一个元素都是有下标的从0开始，最后一个下标为：length-1
13.数组作为这种数据结构的优点缺点：
优点：查询/检索某个下标上的元素时效率极高。可以说是查询效率最高的一个数据结构
第一：每一个元素的内存地址在空间存储上是连续的
第二：每一个元素类型想同，所以占用空间大小一样
第三：知道第一个元素内存地址，知道每一个元素占用空间大小，又知道下标，所以通过一个数学表达式
就可以计算出某个下标上内存的地址，所以数组的检索效率是最高的

​ 数组中存储100个元素，或者存储100w个元素，在元素查询时候，效率都是相同的，因为数组中元素查找的时候
​ 不会一个一个找，是通过数学表达式计算出来的（直接定位的）

​ 缺点：
​ 第一：由于为了保证数组中的每个元素的内存地址连续，所以在数组上随机删除或者增加元素的时候效率较低，因为随机增删
​ 元素会涉及到后面的元素统一向前或向后的位移操作。
​ 第二：数组不能存储大数据量，因为很难在内存空间上找到一块特别大的连续的内存空间。
14.声明/定义一维数组
​ 语法格式：
​ int[] array1;
​ double[] array2;
​ boolean[] array3;
15.初始化一维数组
​ 包括两种方式：静态初始化一维数组，动态初始化一维数组。
​ 静态初始化语法格式：
​ int[] array = {100,200,300};
​ 动态初始化语法格式：
​ int[] array = new int[5];//这里的5代表数组的元素个数，每个元素的默认值为0
​ String[] names = new String[6];//初始化String类型的数组长度为6的数组，每个元素默认值null

package array;
/*
Array
    1.Java中的数组是一种引用数据类型，不属于基本数据类型，数组的父类时Object
    2.数组实际上是一个容器，可以容纳多个元素。数组字面意思：一组数据
    3.数组当中可以存储基本数据类型的数据，也可以存储引用数据类型的数据
    4.数组因为是引用类型，所以数组对象是存储在堆内存中的，数组存放放在堆当中
        Person p1 = new Person();
        Person p2 = new Person();
    5.数组在内存方面：
        数组当中如果存储的是”java对象“的话，实际上存储的是对象的”引用(内存地址)“，数组中不能直接存储java对象
    6.数组一旦创建，在java中规定长度不可变
    7.数组的分类：一维、二维、三维、多维...
    8.所有的数组对象都有length属性，用来获取数组中元素的个数
    9.java中的数组要求数组中的元素类型统一。比如：int类型数组只能存储int，person类型只能存储person
    10.数组在内存方面存储的时候，数组中的元素内存地址是连续的（存储的每一个元素都是有规则的挨着排列的），内存地址连续
        这是数组的存储特点，实际上数组是一种简单的数据结构
    11.所有的数组都是拿”第一个小方块的内存地址“作为第一个内存地址(数组中的首元素内存地址，作为数组的内存地址)
    12.数组每一个元素都是有下标的从0开始，最后一个下标为：length-1
    13.数组作为这种数据结构的优点缺点：
        优点：查询/检索某个下标上的元素时效率极高。可以说是查询效率最高的一个数据结构
            第一：每一个元素的内存地址在空间存储上是连续的
            第二：每一个元素类型想同，所以占用空间大小一样
            第三：知道第一个元素内存地址，知道每一个元素占用空间大小，又知道下标，所以通过一个数学表达式
                    就可以计算出某个下标上内存的地址，所以数组的检索效率是最高的
        数组中存储100个元素，或者存储100w个元素，在元素查询时候，效率都是相同的，因为数组中元素查找的时候
        不会一个一个找，是通过数学表达式计算出来的（直接定位的）

    缺点：
        第一：由于为了保证数组中的每个元素的内存地址连续，所以在数组上随机删除或者增加元素的时候效率较低，因为随机增删
    元素会涉及到后面的元素统一向前或向后的位移操作。
        第二：数组不能存储大数据量，因为很难在内存空间上找到一块特别大的连续的内存空间。
14.声明/定义一维数组
    语法格式：
        int[] array1;
        double[] array2;
        boolean[] array3;
15.初始化一维数组
    包括两种方式：静态初始化一维数组，动态初始化一维数组。
    静态初始化语法格式：
    int[] array = {100,200,300};
    动态初始化语法格式：
    int[] array = new int[5];//这里的5代表数组的元素个数，每个元素的默认值为0
    String[] names = new String[6];//初始化String类型的数组长度为6的数组，每个元素默认值null

*/
public class Test01 {
public static void main(String[] agrs){
//使用静态初始化的方式，int类型
int[] a1 = { 1,2,3,4};
//数组中元素的下标
//所有的数组对象都有length属性
System.out.println(a1.length);
System.out.println(“第一个元素：” + a1[0]);
System.out.println(“最后一个元素：” + a1[a1.length - 1]);
System.out.println(“------------------------”);

    a1<span class="token punctuation">[</span><span class="token number">0</span><span class="token punctuation">]</span> <span class="token operator">=</span> <span class="token number">11</span><span class="token punctuation">;</span>
    a1<span class="token punctuation">[</span>a1<span class="token punctuation">.</span>length <span class="token operator">-</span> <span class="token number">1</span><span class="token punctuation">]</span> <span class="token operator">=</span> <span class="token number">0</span><span class="token punctuation">;</span>
    <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span><span class="token string">"第一个元素："</span> <span class="token operator">+</span> a1<span class="token punctuation">[</span><span class="token number">0</span><span class="token punctuation">]</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
    <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span><span class="token string">"最后一个元素："</span> <span class="token operator">+</span> a1<span class="token punctuation">[</span>a1<span class="token punctuation">.</span>length <span class="token operator">-</span> <span class="token number">1</span><span class="token punctuation">]</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
    <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span><span class="token string">"------------------------"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>

    <span class="token keyword">for</span><span class="token punctuation">(</span><span class="token keyword">int</span> i <span class="token operator">=</span> <span class="token number">0</span><span class="token punctuation">;</span>i<span class="token operator">&lt;</span>a1<span class="token punctuation">.</span>length<span class="token punctuation">;</span>i<span class="token operator">++</span><span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
        <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span>a1<span class="token punctuation">[</span>i<span class="token punctuation">]</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
    <span class="token punctuation">}</span>
    <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span><span class="token string">"------------------------"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
    <span class="token comment">//System.out.println(a1[5]);//ArrayIndexOutOfBoundsException异常</span>

    <span class="token keyword">for</span><span class="token punctuation">(</span><span class="token keyword">int</span> i <span class="token operator">=</span> a1<span class="token punctuation">.</span>length <span class="token operator">-</span> <span class="token number">1</span><span class="token punctuation">;</span> i <span class="token operator">&gt;=</span> <span class="token number">0</span><span class="token punctuation">;</span> i<span class="token operator">--</span><span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
        <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span>a1<span class="token punctuation">[</span>i<span class="token punctuation">]</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
    <span class="token punctuation">}</span>
<span class="token punctuation">}</span>

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75

16.采用静态初始化方式和动态初始化方式时间

采用静态初始化方式：当你创建数组的时候，确定数组中存储哪些具体的元素时，可以采用静态初始化方式
采用动态初始化方式：当你创建数组的时候，不确定确定数组中存储哪些具体的元素时，可以采用动态初始化方式

package array;
/*
关于每个类型的默认值：
    数据类型                默认值
    ----------------------------
    byte                    0
    short                   0
    int                     0
    long                    0l
    double                  0.0
    float                   0.0F
    boolean                 false
    char                    \u0000
    引用数据类型              null
采用静态初始化方式：当你创建数组的时候，确定数组中存储哪些具体的元素时，可以采用静态初始化方式
采用动态初始化方式：当你创建数组的时候，不确定确定数组中存储哪些具体的元素时，可以采用动态初始化方式

*/
public class Test02 {
public static void main(String[] args){
int[] a = new int[4];//默认值都为0
for (int i = 0;i< a.length; i++){
System.out.println(a[i]);
}
a[0] = 1;
a[1] = 2;
a[2] = 3;
a[3] = 4;
//初始化一个Object类型的数组，采用动态初始化方法，默认值都为null
System.out.println(“-------------”);
Object[] objs = new Object[3];
for(int i = 0; i<objs.length; i++){
System.out.println(objs[i]);
}
System.out.println(“-------------”);
String[] strs = new String[3];
for(int i = 0; i< strs.length; i++){
System.out.println(strs[i]);
}
System.out.println(“-------------”);
String[] strs2 = { “abc”,“def”,“ghi”};
for (int i = 0; i< strs2.length; i++){
System.out.println(strs2[i]);
}
System.out.println(“-------------”);
//存储Object
Object o1 = new Object();
Object o2 = new Object();
Object o3 = new Object();
Object[] objects = { o1,o2,o3};
for (int i = 0; i< objects.length; i++){
System.out.println(objects[i]);
}

<span class="token punctuation">}</span>

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57

17.当一个方法上的参数类型是一个数组的时候，方法的传参方式

package array;
//当一个参数上，方法的类型是一个数组的时候。
public class Test03 {
    public static void main(String[] args){
        System.out.println("hello word");
        //调用方法传数组
        int[] x = {1,2,3,4};
        printArray(x);
        System.out.println("-----------------");
        String[] strs = {"abc","def","ghi"};
        printArray(strs);
        System.out.println("-----------------");
        String[] strs2 = new String[6];
        printArray(strs2);
<span class="token punctuation">}</span>
<span class="token keyword">public</span> <span class="token keyword">static</span> <span class="token keyword">void</span> <span class="token function">printArray</span><span class="token punctuation">(</span><span class="token keyword">int</span><span class="token punctuation">[</span><span class="token punctuation">]</span> array<span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
    <span class="token keyword">for</span><span class="token punctuation">(</span><span class="token keyword">int</span> i <span class="token operator">=</span> <span class="token number">0</span><span class="token punctuation">;</span> i<span class="token operator">&lt;</span> array<span class="token punctuation">.</span>length<span class="token punctuation">;</span> i<span class="token operator">++</span><span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
        <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span>array<span class="token punctuation">[</span>i<span class="token punctuation">]</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
    <span class="token punctuation">}</span>
<span class="token punctuation">}</span>
<span class="token keyword">public</span> <span class="token keyword">static</span> <span class="token keyword">void</span> <span class="token function">printArray</span><span class="token punctuation">(</span><span class="token class-name">String</span><span class="token punctuation">[</span><span class="token punctuation">]</span> args<span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
    <span class="token keyword">for</span><span class="token punctuation">(</span><span class="token keyword">int</span> i <span class="token operator">=</span> <span class="token number">0</span><span class="token punctuation">;</span> i<span class="token operator">&lt;</span> args<span class="token punctuation">.</span>length<span class="token punctuation">;</span> i<span class="token operator">++</span><span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
        <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span>args<span class="token punctuation">[</span>i<span class="token punctuation">]</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
    <span class="token punctuation">}</span>
<span class="token punctuation">}</span>

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28

package array;
/*
当一个方法的参数是一个数组的时候，还可以采用
 */
public class Test04 {
    public  static  void main(String[] args){
        //静态初始化
        int[] a = {1,2,3};
        printArray(a);
        System.out.println("------------------");
        //如果直接传递一个静态数组，语法如下。
        printArray(new  int[]{1,2,3,});
        //动态初始化一维数组\
        System.out.println("------------------");
        int[] a2 = new int[4];
        printArray(a2);
        System.out.println("------------------");
        printArray(new int[3]);
    }
    public static void printArray(int[] array){
        for(int i = 0; i< array.length; i++){
            System.out.println(array[i]);
        }
    }
}

 
 

 
 

  
  
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

18.main方法中的“String[] args”有什么作用
JVM负责调用main方法的时候会自动传一个String数组过来。

package array;
/*
1.main方法中的“String[] args”有什么作用
    JVM负责调用main方法的时候会自动传一个String数组过来。
 */
public class Test05 {
    //JVM调用的时候一定会传递一个String数组
    public static void main(String[] args){
        //JVM默认传递过来的这个数组的长度为0
        //通过测试得出args不为null。不是空引用
        System.out.println("JVM给传递的String数组参数，这个数组的长度" + args.length);
        //这个数组什么时候里面会有值呢，其实这个数组是留给用户的，用户可以在控制台上输入参数，这个参数会被
        //自动转为String数组
        //例如：java Test02 abc def xyz
        //那么这个时候JVM会自动将abc def xyz通过空格的方式进行分离，分离完成之后，自动放到String[] args这个数组当中
        //所以main方法上面的String数组，主要是用来接收用户输入参数的
    //数组对象创建了，但是数组中没有任何东西
    /*String[] strs = new String[0];
    printArray(strs);*/

    for(int i = 0;i < args.length;i++) {
        System.out.println(args[i]);
    }
}
public static void printArray(String[] args){
    System.out.println(args.length);
}

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30

19.模拟一个系统，假设这个系统要使用，必须输入用户名和密码

package array;
/*
模拟一个系统，假设这个系统要使用，必须输入用户名和密码

/
public class Test06 {
/
用户名密码输入args中
*/
public static void main(String[] args){
System.out.println(“请输入用户名和密码”);
//程序执行到此，用户确实提供了用户名和密码
//接下来判断是否正确

    <span class="token class-name">String</span> username <span class="token operator">=</span> args<span class="token punctuation">[</span><span class="token number">0</span><span class="token punctuation">]</span><span class="token punctuation">;</span>
    <span class="token class-name">String</span> password <span class="token operator">=</span> args<span class="token punctuation">[</span><span class="token number">1</span><span class="token punctuation">]</span><span class="token punctuation">;</span>

    <span class="token comment">//判断字符串是否相等</span>
    <span class="token keyword">if</span><span class="token punctuation">(</span><span class="token string">"admin"</span><span class="token punctuation">.</span><span class="token function">equals</span><span class="token punctuation">(</span>username<span class="token punctuation">)</span><span class="token operator">&amp;&amp;</span><span class="token string">"123"</span><span class="token punctuation">.</span><span class="token function">equals</span><span class="token punctuation">(</span>password<span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span><span class="token comment">//这样编写可以预防空指针异常</span>
    <span class="token comment">//if(username.equals("admin")&amp;&amp;password.equals("123")){<!-- --></span>
        <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span><span class="token string">"登入成功"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
    <span class="token punctuation">}</span><span class="token keyword">else</span> <span class="token punctuation">{<!-- --></span>
        <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span><span class="token string">"登入成功"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
    <span class="token punctuation">}</span>
<span class="token punctuation">}</span>

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29

20.一维数组的深入

一维数组的深入，数组中存储的类型为：引用数据类型
对于数组来说，实际上只能存储Java对象的内存地址，数组中存储的每个元素是“引用”

package array;
/*
一维数组的深入，数组中存储的类型为：引用数据类型
对于数组来说，实际上只能存储Java对象的内存地址，数组中存储的每个元素是“引用”
 */
public class Test07 {
    public static void main(String[] args){
        //创建一个Animal类型的数组
        Animal a1 = new Animal();
        Animal a2 = new Animal();
        Animal[] animals = {a1,a2};
        for(int i = 0; i<animals.length; i++){
            animals[i].move();
    <span class="token punctuation">}</span>
    <span class="token class-name">System</span><span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span><span class="token string">"---------------"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
    <span class="token class-name">Animal</span><span class="token punctuation">[</span><span class="token punctuation">]</span> ans <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">Animal</span><span class="token punctuation">[</span><span class="token number">2</span><span class="token punctuation">]</span><span class="token punctuation">;</span>
    ans<span class="token punctuation">[</span><span class="token number">0</span><span class="token punctuation">]</span> <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">Animal</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment">//创建一个Animal对象，放入第一个位置</span>
    <span class="token comment">//Animal数组中只能存放Animal数组的类型，不能放其他的</span>
    <span class="token comment">//Animal可以存放Cat类型的数据，因为Cat时Animal的子类</span>
    ans<span class="token punctuation">[</span><span class="token number">1</span><span class="token punctuation">]</span> <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">Cat</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>

    <span class="token class-name">Animal</span><span class="token punctuation">[</span><span class="token punctuation">]</span> anis <span class="token operator">=</span> <span class="token punctuation">{<!-- --></span><span class="token keyword">new</span> <span class="token class-name">Cat</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">,</span><span class="token keyword">new</span> <span class="token class-name">Brid</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">}</span><span class="token punctuation">;</span><span class="token comment">//该数组中存储了两个对象的内存地址</span>
    <span class="token keyword">for</span><span class="token punctuation">(</span><span class="token keyword">int</span> i <span class="token operator">=</span> <span class="token number">0</span><span class="token punctuation">;</span> i<span class="token operator">&lt;</span> anis<span class="token punctuation">.</span>length<span class="token punctuation">;</span> i<span class="token operator">++</span><span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
        <span class="token comment">//这个取出来有可能时Cat，也有可能是Brid,不管肯定是Animal</span>
        <span class="token comment">//如果调用的方法是父类型当中存在的方法，那么不需要向下转型，直接使用父类型调用即可。</span>
        anis<span class="token punctuation">[</span>i<span class="token punctuation">]</span><span class="token punctuation">.</span><span class="token function">move</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
        <span class="token comment">//调用子对象特有的方法时，需要进行类型的判断</span>
        <span class="token keyword">if</span> <span class="token punctuation">(</span>anis<span class="token punctuation">[</span>i<span class="token punctuation">]</span> <span class="token keyword">instanceof</span> <span class="token class-name">Cat</span><span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
            <span class="token punctuation">(</span><span class="token punctuation">(</span><span class="token class-name">Cat</span><span class="token punctuation">)</span> anis<span class="token punctuation">[</span>i<span class="token punctuation">]</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">catchMouse</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span><span class="token comment">//父类型需要转换为子类型</span>
        <span class="token punctuation">}</span>
        <span class="token keyword">if</span><span class="token punctuation">(</span>anis<span class="token punctuation">[</span>i<span class="token punctuation">]</span> <span class="token keyword">instanceof</span> <span class="token class-name">Brid</span><span class="token punctuation">)</span><span class="token punctuation">{<!-- --></span>
            <span class="token punctuation">(</span><span class="token punctuation">(</span><span class="token class-name">Brid</span><span class="token punctuation">)</span> anis<span class="token punctuation">[</span>i<span class="token punctuation">]</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">Sing</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
        <span class="token punctuation">}</span>
    <span class="token punctuation">}</span>
<span class="token punctuation">}</span>

}
class Animal{
public void move(){
System.out.println(“Animal move”);
}
}

class product{

}
class Cat extends Animal{
public void move(){
System.out.println(“Cat move”);
}
public void catchMouse(){
System.out.println(“catch mouse”);
}
}
class Brid extends Animal{
public void move(){
System.out.println(“Brid move”);
}
public void Sing(){
System.out.println(“sing”);
}
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62

21.关于一维数组的扩容

在Java中，数组长度一旦确定不可变，数组满了需要扩容。
Java中对数组的扩容是：
先新建一个大容量的数组，然后将小容量数组中的元素一个个拷贝到大数组当中
结论：数组扩容效率比较低，因为涉及到拷贝问题，所以在以后的开发中，尽可能少的进行数组的拷贝，
最好预估准确数组的长度，这样可以减少数组扩容的次数，提高效率

package array;
/*
关于一维数组的扩容
    在Java中，数组长度一旦确定不可变，数组满了需要扩容。
    Java中对数组的扩容是：
        先新建一个大容量的数组，然后将小容量数组中的元素一个个拷贝到大数组当中
    结论：数组扩容效率比较低，因为涉及到拷贝问题，所以在以后的开发中，尽可能少的进行数组的拷贝，
    最好预估准确数组的长度，这样可以减少数组扩容的次数，提高效率
 */

public class Test08 {
public static void main(String[] args) {
//java中数组是怎么进行拷贝呢？
//System.arraycopy();5个参数
int[] src = { 1, 11, 2, 3, 4};
int[] dest = new int[20];

    <span class="token comment">//利用JDK System类中的arraycopy方法，来完成数组的拷贝</span>
    <span class="token comment">/*System.arraycopy(src,1,dest,3,2);
    for(int i = 0; i&lt; dest.length;i++){
        System.out.println(dest[i]);
    }*/</span>

    <span class="token class-name">System</span><span class="token punctuation">.</span><span class="token function">arraycopy</span><span class="token punctuation">(</span>src<span class="token punctuation">,</span> <span class="token nu