Java基础知识总结（中）

发表于 更新于 分类于 ， 阅读次数：

面向对象与面向过程

  • 面向过程(POP) 与 面向对象(OOP)

    • 二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的 是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对 象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

    • 面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如 抽象、分类、继承、聚合、多态等。

      面向对象：Object Oriented Programming

      面向过程：Procedure Oriented Programming

  • 面向对象的三大特征

    • 封装（Encapsulation）
    • 继承（Inheritance）
    • 多态（Polymorphism）

煮个栗子：

image.png

Java中的基本元素：类和对象

类的语法格式

1
2
3
4
5
6
7
8
9
10
11
修饰符 class 类名{
  属性声明;
  方法申明;
}
例如：
public class Person{
  private int age ; //声明私有变量 age
  public void showAge(int i) { //声明方法showAge( )
  	age = i;
  }
}

对象的创建和使用

  • 创建对象语法：类名 对象名 = new 类名();
  • 用“对象名.对象成员”的方式就能访问对象成员

内存解析：image.png

匿名对象

我们也可以不定义对象的句柄，而直接调用这个对象的方法。这 样的对象叫做匿名对象。

如：new Person().shout();

使用情况：如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。 我们经常将匿名对象作为实参传递给一个方法调用。

类的成员

属性（field）

语法格式： 修饰符 数据类型 属性名 = 初始化值 ;
  • 说明1: 修饰符
    • 常用的权限修饰符有：private、缺省、protected、public
    • 其他修饰符：static、final (暂不考虑)
  • 说明2：数据类型
    • 任何基本数据类型(如int、Boolean) 或 任何引用数据类型。
  • 说明3：属性名
    • 属于标识符，符合命名规则和规范即可。

举例： public class Person{ private int age; //声明private变量 age public String name = “Lila”; //声明public变量 name }

变量的分类（成员变量和局部变量）
  • 在方法体外，类体内声明的变量称为成员变量。
  • 在方法体内部声明的变量称为局部变量。

成员变量和局部变量区别：

成员变量 局部变量
声明的位置 直接声明在类型中 方法内部、代码块内、构造器内
修饰符 private、public、static等 不能用权限修饰符，可以用final修饰
初始化值 有默认初始化值 没有默认初始化值，必须要显示赋值
内存加载位置 堆空间或静态域内 栈空间

方法（method）

方法的声明格式：
1
2
3
4
修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛
	方法体程序代码
	return 返回值;
｝

其中： 修饰符：public,缺省,private, protected等 返回值类型：

  • 没有返回值：void。
  • 有返回值，声明出返回值的类型。与方法体中“return 返回值”搭配使用 方法名：属于标识符，命名时遵循标识符命名规则和规范，“见名知意” 形参列表：可以包含零个，一个或多个参数。多个参数时，中间用“,”隔开 返回值：方法在执行完毕后返还给调用它的程序的数据。
方法的调用
image.png
方法的重载（overload）

1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

  • “两同一不同”:同一个类、相同方法名

  • 参数列表不同：参数个数不同，参数类型不同

使用重载方法，可以为编程带来方便。

例如，System.out.println()方法就是典型的重载方法，其内部的声 明形式如下：

public void println(byte x)

public void println(short x)

public void println(int x)

public void println(long x)

public void println(float x)

public void println(double x)

public void println(char x)

public void println(double x)

public void println()

……

可变个数的形参

1.JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定 义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。

1
2
3
4
5
//JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量 
public static void test(int a ,String[] books); 

//JDK5.0：采用可变个数形参来定义方法，传入多个同一类型变量 
public static void test(int a ,String … books);

2.具体使用：

  • 2.1 可变个数形参的格式：数据类型 … 变量名

  • 2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。

  • 2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载

  • 2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。

  • 2.5 可变个数形参在方法的形参中，必须声明在末尾

  • 2.6 可变个数形参在方法的形参中,最多只能声明一个可变形参。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void test(String[] msg){
	System.out.println(“含字符串数组参数的test方法 ");
}
public void test1(String book){
	System.out.println(“****与可变形参方法构成重载的test1方法****");
}
public void test1(String ... books){
	System.out.println("****形参长度可变的test1方法****");
}
public static void main(String[] args){
TestOverload to = new TestOverload();
  //下面两次调用将执行第二个test方法
  to.test1();
  to.test1("aa" , "bb");
  //下面将执行第一个test方法
  to.test(new String[]{"aa"});
}
方法参数的值传递机制

方法，必须由其所在类或对象调用才有意义。若方法含有参数：

  • 形参：方法声明时的参数
  • 实参：方法调用时实际传给形参的参数值

Java的实参值如何传入方法呢？

Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

  • 形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
  • 形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参
image.png image.png image.png image.png image.png

构造器（构造方法）

构造器的特征
  • 它具有与类相同的名称
  • 它不声明返回值类型。（与声明为void不同）
  • 不能被static、final、synchronized、abstract、native修饰，不能有 return语句返回值
构造器的作用
  • 创建对象
  • 给对象进行初始化
分类

根据参数不同，构造器可以分为如下两类：

  • 隐式无参构造器（系统默认提供）
  • 显式定义一个或多个构造器（无参、有参）

注意：

  1. Java语言中，每个类都至少有一个构造器
  2. 默认构造器的修饰符与所属类的修饰符一致
  3. 一旦显式定义了构造器，则系统不再提供默认构造器
  4. 一个类可以创建多个重载的构造器
  5. 父类的构造器不可被子类继承
构造器的重载

构造器重载，参数列表必须不同

1
2
3
4
5
6
public class Person{
  public Person(String name, int age, Date d) {this(name,age);…}
  public Person(String name, int age) {…}
  public Person(String name, Date d) {…}
  public Person(){…}
}

JavaBean

JavaBean是一种Java语言写成的可重用组件。

所谓javaBean，是指符合如下标准的Java类：

  • 类是公共的
  • 有一个无参的公共的构造器
  • 有属性，且有对应的get、set方法

用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以 用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP 页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用 户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关 心任何改变。

UML类图

image.png

面向对象的特征之一：封装

为什么需要封装？

  • 封装的作用和含义？

    • 我要用洗衣机，只需要按一下开关和洗涤模式就可以了。有必要了解洗衣机内 部的结构吗？有必要碰电动机吗？
    • 我要开车，…

  • 我们程序设计追求“高内聚，低耦合”。

    • 高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；
    • 低耦合 ：仅对外暴露少量的方法用于使用。
    • 隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提 高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

使用者对类内部定义的属性(对象的成员变量)的直接操作会导致数据的错误、混乱或安全性问题

应该将legs属性保护起来， 防止乱用。

保护的方式：信息隐藏

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Animal {
  public int legs;
  public void eat(){
  	System.out.println("Eating");
  }
  public void move(){
  	System.out.println("Moving.");
  }
}
public class Zoo {
  public static void main(String args[]) {
    Animal xb = new Animal();
    xb.legs = 4;
    System.out.println(xb.legs);
    xb.eat();
    xb.move();
  }
}

Java中通过将数据声明为私有的(private)，再提供公共的（public） 方法:getXxx()和setXxx()实现对该属性的操作，以实现下述目的：

  • 隐藏一个类中不需要对外提供的实现细节；
  • 使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑， 限制对属性的不合理操作；
  • 便于修改，增强代码的可维护性；

四种权限修饰符

修饰符 内部类 同一个包 不同的子包 同一个工程
private √
（缺省） √ √
protected √ √ √
public √ √ √ √

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

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

关键字this的使用

在Java中，this关键字比较难理解，它的作用和其词义很接近。

  • 它在方法内部使用，即这个方法所属对象的引用；
  • 它在构造器内部使用，表示该构造器正在初始化的对象

this 可以调用类的属性、方法和构造器

什么时候可以用this关键字

当在方法内需要用到调用该方法的对象时，就用this。 具体的：我们可以用this来区分属性和局部变量。 比如：this.name = name;

调用属性和方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Person{ // 定义Person类
  private String name ;
  private int age ;
  public Person(String name,int age){
    this.name = name ;
    this.age = age ; 
  }
  public void getInfo(){
    System.out.println("姓名：" + name) ;
    this.speak();
  }
  public void speak(){
  	System.out.println(“年龄：” + this.age);
  }
}

当前正在操作本方法的对 象称为当前对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Person{ // 定义Person类
  String name;
  Person(String name){
  	this.name = name;
  }
  public void getInfo(){
  	System.out.println("Person类 --> " + this.name) ; 
  }
  public boolean compare(Person p){
  	return this.name==p.name;
  } 
}
public class PersonTest{
  public static void main(String args[]){
    Person per1 = new Person("张三") ;
    Person per2 = new Person("李四") ;
    per1.getInfo() ; // 当前调用getInfo()方法的对象是per1
    per2.getInfo() ; // 当前调用getInfo()方法的对象是per2
    boolean b = per1.compare(per2);
  } 
}

调用构造器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Person{ // 定义Person类
  private String name ;
  private int age ;
  public Person(){ // 无参构造器
  	System.out.println("新对象实例化") ;
  }
  public Person(String name){
    this(); // 调用本类中的无参构造器
    this.name = name ;
  }
  public Person(String name,int age){
    this(name) ; // 调用有一个参数的构造器
    this.age = age;
  }
  public String getInfo(){
  	return "姓名：" + name + "，年龄：" + age ;
  }
}

面向对象的特征之二：继承

1
2
3
4
5
6
7
8
9
10
11
class Person {
  public String name;
  public int age;
  public Date birthDate;
  public String getInfo() {
  // ...
  }
}
class Student extends Person {
	public String school;
}

为什么要有继承？

  • 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中， 那么多个类无需再定义这些属性和行为，只要继承那个类即可。

  • 此处的多个类称为子类(派生类)，单独的这个类称为父类(基类 或超类)。可以理解为:“子类 is a 父类”

  • 类继承语法规则: class Subclass extends SuperClass{ }

作用

  • 继承的出现减少了代码冗余，提高了代码的复用性。
  • 继承的出现，更有利于功能的扩展。
  • 继承的出现让类与类之间产生了关系，提供了多态的前提。

注意

  1. 子类继承了父类，就继承了父类的方法和属性，

    但是子类不能直接访问父类中私有的(private)的成员变量和方法。

  2. 在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和 方法。

  3. 在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集， 而是对父类的“扩展”。

  4. Java只支持单继承和多层继承，不允许多重继承

  5. 一个子类只能有一个父类

    • 一个父类可以派生出多个子类
    • class SubDemo extends Demo{ } //ok
    • class SubDemo extends Demo1,Demo2…//error

方法的重写（override/overwrite）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Person {
  public String name;
  public int age;
  public String getInfo() {
  	return "Name: "+ name + "\n" +"age: "+ age;
  }
}
public class Student extends Person {
  public String school;
  public String getInfo() { //重写方法
  	return "Name: "+ name + "\nage: "+ age + "\nschool: "+ school;
	}
	public static void main(String args[]){
    Student s1=new Student();
    s1.name="Bob";
    s1.age=20;
    s1.school="school2";
    System.out.println(s1.getInfo()); //Name:Bob age:20 school:school2
  }
}

定义

在子类中可以根据需要对从父类中继承来的方法进行改造，也称 为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。

要求

  1. 子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
  2. 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
  3. 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限
    • 子类不能重写父类中声明为private权限的方法
  4. 子类方法抛出的异常不能大于父类被重写方法的异常
注意

子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为 static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。

super关键字

  • 在Java类中使用super来调用父类中的指定操作：

  • super可用于访问父类中定义的属性

  • super可用于调用父类中定义的成员方法

  • super可用于在子类构造器中调用父类的构造器

  • 注意

    • 尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员
    • super的追溯不仅限于直接父类
    • super和this的用法相像，this代表本类对象的引用，super代表父类的内存 空间的标识

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Person {
  protected String name = "张三"; 
  protected int age;
  public String getInfo() {
	  return "Name: " + name + "\nage: " + age;
  }
}
class Student extends Person {
   protected String name = "李四";
   private String school = "New Oriental";
   public String getSchool() {
      return school;
  }
  public String getInfo() {
    return super.getInfo() + "\nschool: " + school;
   }
}

调用父类的构造器

  • 子类中所有的构造器默认都会访问父类中的空参构造器
  • 当父类中没有空参构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的 构造器。同时，只能”二选一” ，且必须放在构造器的首行
  • 如果子类构造器中既未显式调用父类或本类的构造器，且父类中又 没有无参的构造器，则编译出错
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
public class Person {
  private String name;
  private int age;
  private Date birthDate;
  public Person(String name, int age, Date d) {
    this.name = name;
    this.age = age;
    this.birthDate = d;
  }
  public Person(String name, int age) {
    this(name, age, null);
  }
  public Person(String name, Date d) {
    this(name, 30, d);
  }
  public Person(String name) {
    this(name, 30);
  }
}

public class Student extends Person {
  private String school;
  public Student(String name, int age, String s) {
    super(name, age);
    school = s;
  }
  public Student(String name, String s) {
    super(name);
    school = s;
  }
  public Student(String s) {// 编译出错: no super(),系统将调用父类无参数的构造器。
  	school = s;
  }
}

子类对象的实例化过程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Creature {
  public Creature() {
  	System.out.println("Creature无参数的构造器");
  }
}
class Animal extends Creature {
  public Animal(String name) {
	  System.out.println("Animal带一个参数的构造器，该动物的name为" + name);
	}
	public Animal(String name, int age) {
    this(name);
    System.out.println("Animal带两个参数的构造器，其age为" + age);
  }
}
public class Wolf extends Animal {
  public Wolf() {
  	super("灰太狼", 3);
	  System.out.println("Wolf无参数的构造器");
  }
  public static void main(String[] args) {
  	new Wolf();
  }
}

面向对象的特征之三：多态

  • 多态性，是面向对象中最重要的概念，在Java中的体现

    对象的多态性：父类的引用指向子类的对象

    • 可以直接应用在抽象类和接口上

  • Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。简 称：编译时，看左边；运行时，看右边。

    • 若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)

    • 多态情况下， “看左边” ：看的是父类的引用（父类中不具备子类特有的方法）

      ​ “看右边” ：看的是子类的对象（实际运行的是子类重写父类的方法）

  • 对象的多态 —在Java中,子类的对象可以替代父类的对象使用

    • 一个变量只能有一种确定的数据类型
    • 一个引用类型变量可能指向(引用)多种不同类型的对象

前提

  • 存在继承或者实现关系
  • 有方法的重写
1
2
3
Person p = new Student();
Object o = new Person();//Object类型的变量o，指向Person类型的对象
o = new Student(); //Object类型的变量o，指向Student类型的对象

子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向 上转型(upcasting)。

  • 一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，

    那么该变量就不能再访问子类中特有的属性

1
2
3
4
Student m = new Student();
m.school = “pku”; //合法,Student类有school成员变量
Person e = new Student();
e.school = “pku”; //非法,Person类没有school成员变量

属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编 译错误。

虚拟方法调用

正常的方法调用 :

1
2
3
4
Person e = new Person();
e.getInfo();
Student e = new Student();
e.getInfo();

虚拟方法调用(多态情况下) :

子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父 类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法 确定的。

1
2
Person e = new Student();
e.getInfo(); //调用Student类的getInfo()方法

instanceof 操作符

x instanceof A：检验x是否为类A的对象，返回值为boolean型。

  • 要求x所属的类与类A必须是子类和父类的关系，否则编译错误
  • 如果x属于类A的子类B，x instanceof A值也为true

对象类型转换（Casting）

基本数据类型的Casting：

  • 自动类型转换：小的数据类型可以自动转换成大的数据类型
    • 如long g=20; double d=12.0f
  • 强制类型转换：可以把大的数据类型强制转换(casting)成小的数据类型
    • 如 float f=(float)12.0; int a=(int)1200L

对Java对象的强制类型转换称为造型

  • 从子类到父类的类型转换可以自动进行

  • 从父类到子类的类型转换必须通过造型(强制类型转换)实现

  • 无继承关系的引用类型间的转换是非法的

  • 在造型前可以使用instanceof操作符测试一个对象的类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class ConversionTest {
  public static void main(String[] args) {
    double d = 13.4;
    long l = (long) d;//基本数据类型的装换
    System.out.println(l);
    int in = 5;
    // boolean b = (boolean)in;
    Object obj = "Hello";
    String objStr = (String) obj;
    System.out.println(objStr);
    Object objPri = new Integer(5);
    // 所以下面代码运行时引发ClassCastException异常
    String str = (String) objPri;
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Test {
  public void method(Person e) { // 设Person类中没有getschool() 方法
    // System.out.pritnln(e.getschool()); //非法,编译时错误
    if (e instanceof Student) {
      Student me = (Student) e; // 将e强制转换为Student类型
      System.out.pritnln(me.getschool());
    }
  }
  public static void main(String[] args){
    Test t = new Test();
    Student m = new Student();
    t.method(m);
  }
}
image.png

继承成员变量和方法的区别：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Base {
  int count = 10;
  public void display() {
  	System.out.println(this.count);
  }
}
class Sub extends Base {
  int count = 20;
  public void display() {
  	System.out.println(this.count);
  }
}
public class FieldMethodTest {
  public static void main(String[] args){
    Sub s = new Sub();
    System.out.println(s.count);//20
    s.display();//20
    Base b = s;
    System.out.println(b == s);//true
    System.out.println(b.count);//10
    b.display();//20
  }
}

子类继承父类

  • 若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中。
  • 对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量。

Object类的使用

  • Object类是所有Java类的根父类
  • 如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
1
2
3
4
5
6
7
public class Person {
...
}
等价于：
public class Person extends Object {
...
}

Object类中的主要结构

方法名 类型 描述
public Object() 构造器 构造器
public boolean equals(Object obj) 方法 对象比较
public int hashCode() 方法 获取Hash码
public Sting toString() 方法 打印对象的信息

==和equals()方法

  • ==
    • 基本类型比较值:只要两个变量的值相等，即为true。
    • 引用类型比较引用(是否指向同一个对象)：只有指向同一个对象时，==才返回true

用“==”进行比较时，符号两边的数据类型必须兼容(可自动转换的基本 数据类型除外)，否则编译出错

  • equals()方法

    源码：

    1
    2
    3
    public boolean equals(Object obj) {
      return (this == obj);
    }

    • equals()：所有类都继承了Object，也就获得了equals()方法。还可以重写。

      只能比较引用类型，其作用与“==”相同,比较是否指向同一个对象。

      格式:obj1.equals(obj2)

    • 特例：当用equals()方法进行比较时，对类File、String、Date及包装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对 象；

      原因：这些类型中重写了Object中的equals()方法

    • 当自定义使用equals()时，可以重写。用于比较两个对象的“内容”是否都相等。

==和equals()的区别
  1. == 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址。
  2. equals的话，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也是==，String等类的equals方法是被重写过的，而且String类在日常开发中用的比较多，久而久之，形成了equals是比较值的错误观点。
  3. 具体要看自定义类里有没有重写Object的equals方法来判断。
  4. 通常情况下，重写equals方法，会比较类中的相应属性的值是否都相等

toString()方法

  • toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址。

    源码：

    1
    2
    3
    public String toString() {
      return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

  • 在进行String与其它类型数据的连接操作时，自动调用toString()方法

    Date now=new Date();

    System.out.println(“now=”+now); 相当于

    System.out.println(“now=”+now.toString());

  • 可以根据需要在用户自定义类型中重写toString()方法 如String 类重写了toString()方法，返回字符串的值。

包装类的使用

  • 针对八种基本数据类型定义相应的引用类型—包装类（封装类）

  • 有了类的特点，就可以调用类中的方法，Java才是真正的面向对象

    基本数据类型 包装类
    byte Byte
    short Short
    int Integer
    long Long
    float Float
    double Double
    boolean Boolean
    char Charater
基本数据类型包装成包装类的实例 —>装箱

  • 通过包装类的构造器实现：

    1
    2
    int i = 500; 
    Integer t = new Integer(i);

  • 还可以通过字符串参数构造包装类对象：

1
2
Float f = new Float(“4.56”); 
Long l = new Long(“asdf”); //NumberFormatException
获得包装类对象中包装的基本类型变量 —>拆箱

  • 调用包装类的.xxxValue()方法：

    boolean b = bObj.booleanValue();

  • JDK1.5之后，支持自动装箱，自动拆箱，但类型必须匹配。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    //自动装箱：基本数据类型 --->包装类
    int num2 = 10;
    Integer in1 = num2;//自动装箱

    boolean b1 = true;
    Boolean b2 = b1;//自动装箱

    //自动拆箱：包装类--->基本数据类型
    System.out.println(in1.toString());

    int num3 = in1;//自动拆箱
字符串转换成基本数据类型
  1. 通过包装类的构造器实现： int i = new Integer(“12”);
  2. 通过包装类的parseXxx(String s)静态方法实现： Float f = Float.parseFloat(“12.1”);
基本数据类型转换成字符串
  1. 调用字符串重载的valueOf()方法： String fstr = String.valueOf(2.34f);
  2. 更直接的方式： String intStr = 5 + “”;

包装类使用举例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int i = 500;
Integer t = new Integer(i);
//装箱：包装类使得一个基本数据类型的数据变成了类。
//有了类的特点，可以调用类中的方法。
String s = t.toString(); // s = "500",t是类，有toString方法
String s1 = Integer.toString(314); // s1= "314" 将数字转换成字符串。
String s2=“4.56”;
double ds=Double.parseDouble(s2); //将字符串转换成数字
//拆箱：将数字包装类中内容变为基本数据类型。
int j = t.intValue(); // j = 500，intValue取出包装类中的数据
//包装类在实际开发中用的最多的在于字符串变为基本数据类型。
String str1 = "30" ;
String str2 = "30.3" ;
int x = Integer.parseInt(str1) ; // 将字符串变为int型
float f = Float.parseFloat(str2) ; // 将字符串变为int型

MVC设计模式

MVC是常用的设计模式之一，将整个程序分为三个层次：视图模型层，控制器层，与 数据模型层。这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式 使程序结构变的灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程 序的耦合性。

1.模型层 model 主要处理数据

  • 数据对象封装 model.bean/domain
  • 数据库操作类 model.dao
  • 数据库 model.db

2.控制层 controller 处理业务逻辑

  • 应用界面相关 controller.activity
  • 存放fragment controller.fragment
  • 显示列表的适配器 controller.adapter
  • 服务相关的 controller.service
  • 抽取的基类 controller.base

3.视图层 view 显示数据

  • 相关工具类 view.utils
  • 自定义view view.ui

import关键字

  1. 在源文件中使用import显式的导入指定包下的类或接口
  2. 声明在包的声明和类的声明之间
  3. 如果需要导入多个类或接口，那么就并列显式多个import语句即可
  4. 举例：可以使用java.util.*的方式，一次性导入util包下所有的类或接口
  5. 如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句
  6. 如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的 是哪个类
  7. 如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入
  8. import static组合的使用：调用指定类或接口下的静态的属性或方法

JDK中主要的包介绍

  1. java.lang—-包含一些Java语言的核心类，如String、Math、Integer、 System和 Thread，提供常用功能

  2. java.net—-包含执行与网络相关的操作的类和接口。

  3. java.io —-包含能提供多种输入/输出功能的类。

  4. java.util—-包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日 期日历相关的函数。

  5. java.text—-包含了一些java格式化相关的类

  6. java.sql—-包含了java进行JDBC数据库编程的相关类/接口

  7. java.awt—-包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这 些类被用来构建和管理应用程序的图形用户界面(GUI)。 B/S C/S