2020.12.08韩德云

2020.12.08

一,包

包时管理类和接口的,类和接口须定义在包中.

包:package

包 = 目录

类 = 文件

1,定义包

语法:

pacKage 包名

解析:

1) :package 是关键字

2) : 定义包必须是Java源文件的第一行代码

3) : 包名必须小写

包的作用:

1,存放类

2,防止类名冲突

3,在更广泛的范围内保护类,数据和方法.

2,使用包

使用包就是将保重的类导入到使用的地方.

例:

import java.util.Arrays;
import java.util.Scanner;
import java.util.*;

"*"表示导入保重所有的类.

3,系统包

java.lang.* : 默认包中的所有类都导入.例如:String,Math,System.

java.util.* : 工具包,例如:Scanner,Arrays,Random.

java.text.* :国际化程序支持包.SimpleDateFormat

4,java中的常量

二,关键字

static : 翻译为静态

1,static的使用:

static 可以修饰内部类,属性,方法,静态块

例:

public class Person {
    public static int live = 1;//static 修饰属性
    
    public static void sayHello() {//static 修饰方法
        
    }
    static class Student{//static修饰内部类
        String name;
    }
    static {//静态块1
        
    }
    static {//静态块2
        
    }
}

2,static和instences的区别

Instences可以翻译成实例,就是new 出来的对象.例:

rpbxgg.png

解析:

(1) 静态成员和实例成员分配内存的时机

静态成员是在类名首次出现时,最先分配内存的,静态属性分配在方法区中。然后调用静态块,多个静态块按照定义的顺序从上到下调用。

实例成员是在实例化时分配内存的,如果没有实例化对象那么实例成员就没有分配内存。

(2) 静态成员和实例成员分配内存的次数

静态成员只分配一次内存,因此静态成员只有一份

实例成员分配内存的次数由实例化的次数决定,每实例化一次分配一次内存。

(3) 静态成员和实例成员的调用规则

静态成员由类名调用,也可以由对象名调用,但是不推荐使用对象名调用。

实例成员由对象名调用,不能使用类名调用。

这种调用规则是因为

静态属于类成员,因此静态成员也称为类成员(类变量,类方法)

实例属性对象成员

(4) 静态块的作用

实例属性可以通过构造函数初始化。

静态属性可以通过静态块初始化,因为类名首次出现时先为静态变量分配内存,然后就调用静态块。

三,Java中的常量

值不可以更改的变量称为常量

使用static final修饰的变量是类常量

使用final修饰变量是实例常量

final是java的关键字,翻译为最终。final可以修饰类,属性,方法。修饰类时不能被继承,修饰方法时不能被子类重写,修饰属性时属性不能改值。

下面的代码定义了类常量和实例常量

**public** **class** Book {

  **public** **static** **final** String ***NAME\***;//定义类常量

  **public** **final** **int** price ;//定义实例常量

  **public** Book(**int** price) {

​    **this**.price = price;//在构造函数中实例常量初始化

  }

  **static** {

​    ***NAME\***="thinking in java";//在静态块中类常量初始化

  }

}

四,继承

使用继承的优点:代码复用,减少代码冗余,增强扩展性。

继承实质上是为了实现多态。

1,如何实现继承

使用extends关键字实现继承

例如:

**class** Father{

}

**class** Sub **extends** Father{

}

子类继承父类后,子类就继承了父类中的成员,导致子类无需从从创建,简化了子类的设计。

五,super与this关键字

super表示父类

this表示子类

1,super的用法1:

在子类构造函数中调用父类构造函数

例如:

  **public** PersonnelDept(String name, String responsibility, String manager,**int** count) {

​     **super**(name,responsibility,manager);

​     **this**.count = count;

   }

注意:super调用父类构造函数时,必须写在子类构造函数的第一行

​ 通常父类定义的属性有父类负责初始化,子类定义的属性由子类负责初始化。子类通过super(参数列表)的方式将子类构造函数中的参数传递给父类,让父类初始化。

2,super的用法2:

在子类的方法中调用父类的方法

例如:

**public** String toString() {

  **return** **super**.toString()+"count="+ count;

}

3,继承中属性的初始化问题

谁定义的属性,由谁初始化

例:

**class** A{

  **int** a;

  **public** A(**int** a) {

​    **this**.a = a;

  }

}

**class** B **extends** A{

  **int** b;

  **public** B(**int** a,**int** b) {

​    **super**(a);

​    **this**.b = b;

  }

}

**class** C **extends** B{

  **int** c;

  **public** C(**int** a,**int** b,**int** c) {

​    **super**(a,b);

​    **this**.c = c;

  }

}

**public** **class** D {

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

​    C c = **new** C(1, 2, 3);

  }

}

调试程序,观察初始化的过程

当前类的构造函数得到的参数中,留下自己定义的函数需要的参数,其余的参数通过super传递给父类初始化。

4,继承中对象实例化的顺序问题

**class** A{

  **int** a;

  **public** A(**int** a) {

​    **this**.a = a;

  }

}

**class** B **extends** A{

  **int** b;

  **public** B(**int** a,**int** b) {

​    **super**(a);

​    **this**.b = b;

  }

}

**class** C **extends** B{

  **int** c;

  **public** C(**int** a,**int** b,**int** c) {

​    **super**(a,b);

​    **this**.c = c;

  }

}

**public** **class** D {

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

​    C c = **new** C(1, 2, 3);

​    c.a= 1;

  }

}

问题:main方法中创建对象c时,jvm到底创建了多少个对象?

答:当实例化一个对象时,该对象的所有父类也都被实例化了。

问题:这些被实例化的对象实例化的顺序是什么?

答:实例化顺序是从父类到子类。

问题:继承中构造函数的调用顺序是?

答:从子类到父类调用

问题:继承中构造函数的执行顺序是?

答:从父类到子类

标签

评论

© 2021 成都云创动力科技有限公司 蜀ICP备20006351号-1