java基础的内容



一、基础

1.命名规范

2.位运算符

二、数组

1.一维数组

• 静态初始化（指定内容）

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…};

• 动态初始化（指定长度）

2.二维数组
二维数组初始化
同一维数组一样，共有4总不同形式的定义方法：

不定长二维数组

3.Java虚拟机的内存划分


4.数组在内存中的存储

以上方法执行，输出的结果是[I@5f，这个是什么呢？是数组在内存中的地址。，而。

三、类和对象

类的语法格式：
修饰符 class 类名{
    属性声明;
    方法声明;
}
说明：修饰符 public：类可以被任意访问类的正文要用{ }括起来

1.对象数组的内存解析

2.匿名对象的使用

3.方法的重载

方法的重载(overload) loading…
  1.定义:在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
  “两同一不同”:
              
  2.举例:Arrays类中重载的sort() / binarySearch()
  3.判断是否重载
  
  4.在通过对象调用方法时，如何确定某一个指定的方法：方法名---->参数列表

可变个数形参的方法
 1.jdk 5.0新增的内容
 2.具体使用：
  
  2.2 当调用可变个数形参的方法时，传入的参数的个数可以是：0个，1个，2个…
  2.3可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载。
  
  2.5可变个数形参在方法中的形参中,必须声明在末尾。
  2.6可变个数形参在方法中的形参中，最多只能声明一个可变形参。

四、面向对象特征之一：封装与隐藏

对于 class 的权限修饰只可以用 public 和 default(缺省)。

• public 类可以在任意地方被访问。
• default 类只可以被同一个包内部的类访问。

4.1、构造器(构造方法)

一、构造器的作用:
  
  
二、说明
  1.如果没有显示的定义类的构造器的话，则系统默认提供一个空参的构造器。
  2.定义构造器的格式:
            
  3.一个类中定义的多个构造器，彼此构成重载。
  4.一旦显示的定义了类的构造器之后，系统不再提供默认的空参构造器。
  5.一个类中，至少会有一个构造器

总结:属性赋值的先后顺序
① 默认初始化值
② 显式初始化
③ 构造器中赋值
④ 通过"对象.方法" 或 “对象.属性”的方式，赋值
以上操作的先后顺序:① - ② - ③ - ④

4.2、this 的使用

this 关键字的使用
 
 2.this 修饰属性和方法:
    this 理解为：当前对象,或当前正在创建的对象。
   2.1 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，。通常情况下，我们都选择省略“this.”。特殊情况下，如果方法的形参和类的属性同名，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
   2.2 。但是，通常情况下，我们都选择省略“this.”。特殊情况下，如果构造器的形参和类的属性同名，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
 
  ① 我们可以在类的构造器中，显式的使用的方式，调用本类中重载的其他的构造器！
  ② 构造器中不能通过"this(形参列表)“的方式调用自己。
  ③ 如果一个类中声明了n个构造器，则最多有n -1个构造器中使用了"this(形参列表)”。
  ④
  ⑤

java基础的内容

4.3、关键字—import

二、import关键字的使用
import:导入
  1.在源文件中显式的使用import结构导入指定包下的类、接口
  2.声明在包的声明和类的声明之间
  3.如果需要导入多个结构，则并列写出即可
  4.可以使用"xxx.*"的方式,表示可以导入xxx包下的所有结构。
  5.如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
  6.如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类。
  7.如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。
  

五、继承

为什么要有继承？
   多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，
   那么多个类无需再定义这些属性和行为，只要继承那个类即可。
一、继承性的好处
  ① 减少了代码的冗余，提高了代码的复用性；
  ② 便于功能的扩展；
  ③ 为之后多态性的使用，提供了前提。
二、继承性的格式
  
  A:子类、派生类、subclass
  B:父类、超类、基类、superclass
  2.1 体现：一旦子类 A 继承父类以后，子类 A 中就获取了父类 B 中声明的结构：属性、方法。特别的，
  2.2 子类继承父类以后，还可以声明自己特有的属性或方法，实现功能的拓展。
子类和父类的关系：不同于子集与集合的关系。
extends:延展、扩展
三、Java 中关于继承性的规定：
  1.一个类可以被多个类继承
  
  3.子父类是相对的概念。
  4.子类直接继承的父类，称为：直接父类。间接继承的父类，称为，间接父类。
  5.子类继承父类后，就获取了直接父类以及所有间接父类中声明的属性和方法。
四、
  1.如果我们没有显式的声明一个类的父类的话，则此类继承于 java.lang.Object 类
  
  3.意味着，所有的 java 类具有 java.lang.Object 类声明的功能。

5.1、方法的重写(override/overwrite)

方法的重写(override/overwrite)
  1.重写：子类继承父类以后，可以对父类中同名同参数的方法进行，覆盖操作。
  2.应用：重写以后，当创建子类对象以后，
3.重写的规定：
    方法的声明：权限修饰符 返回值类型 方法名(形参列表){//方法体 }
  
  ② 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限,
     
  ③ 返回值类型:

5.2、关键字：super

super关键字的使用
  1.super理解为:父类的
  
  3.super的使用
    3.1 我们可以在子类的方法或构造器中,但是，通常情况下，我们习惯去省略这个"super."
    
    
  4.super调用构造器
    4.1 我们可以
    4.2
    4.3 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"
    4.4
    4.5

子类对象实例化过程

子类对象实例化的全过程
1.从结果上看:
  子类继承父类以后，就获取了父类中声明的属性或方法。创建子类的对象中，在堆空间中，就会加载所有父类中声明的属性。
2.从过程上看:
  当我们,直到调用java.lang.Object类中空参的构造器为止。正因为加载过所有的父类结构，所以才可以看到内存中有父类中的结构，子类对象可以考虑进行调用。
  明确:虽然创建子类对象时，调用了父类的构造器，但自始至终就创建过一个对象，即为new的子类对象。

六、多态

面向对象之三:多态性
  1.理解多态性:可以理解为一个事物的多种态性。
  2.何为多态性:
   对象的多态性:
  3.多态的使用：
   有了对象多态性以后，
        简称：编译时，看左边；运行时，看右边。
若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)
多态情况下，
    看左边”：看的是父类的引用（父类中不具备子类特有的方法）
    “看右边”：看的是子类的对象（实际运行的是子类重写父类的方法）
  4.多态性的使用前提：
    ① 类的继承关系
    ② 方法的重写
  

6.1、==操作符与equals方法

一、回顾 ==的使用(运算符)
  1.可以使用在和中
  2.如果比较的是：比较两个变量。(不一定类型要相同)如果比较的是：比较两个对象的是否相同,即
补充: == 符号使用时，必须保证符号左右两边的变量类型一致。
二、equals()方法的使用
  1.是一个方法，而非运算符
  2.只能。
说明：，即两个引用是否指向同一个对象实体。
  4.像String、Date、File、包装类等都重写了Object类中的equals()方法.重写以后，比较的就不是两个引用的地址是否相同，而是比较两个对象的“实体内容”是否相同。
  5.通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。那么，我们就需要对Object类中的equals()进行重写。
重写的原则:比较两个对象的实体内容是否相同。

6.2、toString的使用

6.3、包装类(Wrapper)的使用

包装类的自动拆装箱机
进行基本类型数据和包装类对象之间的互转时：

为了方便使用和性能优化，提供了自动拆装箱机制

七、关键字 static和final

7.1、static

static 关键字的使用
1.static:静态的。

3.使用 static 修饰属性:静态变量(或类变量)。
  3.1 属性:是否使用 static 修饰，又分为:静态属性 VS 非静态属性(实例变量)
     实例变量:我们创建了类的多个对象，每个对象都独立的拥有了一套类中的非静态属性。当修改其中一个非静态属性时，不会导致其他对象中同样的属性值的修饰。
    静态变量:。
  3.2 static 修饰属性的其他说明:
    ① 静态变量。可以。
    ② 静态变量的加载要早于对象的创建。
    ③ 由于类只会加载一次，则静态变量在内存中也。存在方法区的静态域中。
    ④   类变量  实例变量
    类    yes    no
    对象  yes    yes
  3.3 静态属性举例:System.out ;  Math.PI;
4.使用 static 修饰方法:静态方法
  ① 随着类的加载而加载，可以通过的方式调用
  ②    方法    非静态方法
  类    yes       no
  对象  yes       yes
  ③
     
5.static 注意点:
  5.1
  5.2 关于静态属性和静态方法的使用，大家从生命周期的角度去理解。
6.开发中，如何确定一个属性是否需要声明 static 的？
  》 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
  》 类中的常量也常常声明为 static
  开发中，如何确定一个方法是否要声明为 static 的？
  》 操作静态属性的方法，通常设置为 static 的
  》 工具类中的方法，习惯上声明为 static 的。比如：Math、Arrays、Collections

7.2、final

1.final可以用来修饰的结构:类、方法、变量
2.final用来。比如:String类、System类、StringBuffer类
3.final。比如：Object类中的getClass()。
4.final用来
  4.1 final修饰属性，可以考虑赋值的位置有:
  4.2 final修饰局部变量:
    尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。
    一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。

八、代码块、抽象类和抽象方法、接口

8.1、代码块

代码块（或初始化块）
  1.代码块的作用：
  2.代码块如果有的话，
  3.分类:静态代码块 vs 非静态代码块
  4.静态代码块

• 内部可以有输出语句
• 作用:初始化类的信息
• 如果一个类中，定义了多个静态代码块，则按照声明的先后顺序执行
• 静态代码块的执行，优先于非静态代码块的执行

  5.非静态代码块

• 内部可以有输出语句
• 作用:可以在创建对象时，对对象的属性等进行初始化。
• 如果一个类中，定义了多个非静态代码块，则按照声明的先后顺序执行

  对属性可以赋值的位置:
   ①默认初始化
   ②显式初始化
   ③构造器中初始化
   ④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值。
   ⑤在代码块中赋值

8.2、抽象类和抽象方法

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类

 1.abstract:抽象的
 2.abstract 可以用来
 3.abstract

• 此类
• 抽象类中包含构造器，便于子类实例化时调用(涉及:子类对象实例化全过程)
• 开发中，都会提供抽象类的子类，让子类对象实例化，实现相关的操作

 4.abstract

• 抽象方法，
• 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法
• 若子类重写了父类中所有的抽象方法，此子类方可实例化；若子类吗，没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰

abstract 使用上的注意点:
 1.abstract ；
 2.abstract 不能用来修饰私有方法、静态方法、final 的方法、final 的类。

8.3、接口

一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java 不支持多重继承。有了接口，就可以得到多重继承的效果。

另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有 is-a 的关系，仅仅是具有相同的行为特征而已。例如：鼠标、键盘、打印机、扫描仪、摄像头、充电器、MP3 机、手机、数码相机、移动硬盘等都支持 USB 连接。

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个"是不是"的关系，而接口实现则是"能不能"的关系。

接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守。

• 用 interface 来定义。
• 接口中的所有。
• 接口中的所有。
• 接口中。
• 接口采用多继承机制。

 1.接口使用 interface 来定义。
 2.在 Java 中:
 3.如何去定义两个接口:定义接口中的成员
   3.1 JDK7 及以前:只能定义全局常量和抽象方法
      全局常量:public static final 的,但是书写中，可以省略不写。
      抽象方法:public abstract 的
   3.2 JDK8:除了全局常量和抽象方法之外，还可以定义静态方法、默认方法。
 4.
 5.Java 开发中，接口通过让类去实现(implements)的方式来使用。如果实现类覆盖了接口中的所有方法，则此实现类就可以实例化;如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
 6.Java 类可以实现多个接口 -->弥补了 Java 单继承性的局限性
   格式:class AA extends BB implementd CC,DD,EE
 7.接口与接口之间是继承,而且可以多继承
 8.接口的具体使用，体现多态性
   接口的主要用途就是被实现类实现。（面向接口编程）

静态方法：

使用 。可以通过接口直接调用静态方法，并执行其方法体。我们经常在相互一起使用的类中使用静态方法。你可以在标准库中找到像 Collection/Collections 或者 Path/Paths 这样成对的接口和类。

默认方法：

默认方法使用 。可以通过实现类对象来调用。我们在已有的接口中提供新方法的同时，还保持了与旧版本代码的兼容性。

版权声明：

本文来源网络，所有图片文章版权属于原作者，如有侵权，联系删除。

本文网址：https://www.bianchenghao6.com/h6javajc/4401.html