Java学习笔记之面向对象

3.面向对象

基本类型

运算符

流程控制

数组

====================================

面向对象

====================================

* 人为抽象的一种编程模型

* 将问题分解成一个一个独立的小问题，

通过独立解决每个小问题，

来解决复杂问题

* 什么是面向对象

封装、继承、多态

类

对象（实例）

引用

构造方法

this

方法重载

继承

重写

super

多态

instanceof

抽象类

final

static

接口

内部类

类

=======================================

* 类比成“图纸”

* 对事物、算法、逻辑、概念等的抽象

* 封装相关的数据和逻辑运算方法

对象（实例）

=======================================

* 类比成“从图纸创建的产品”

* 从类创建出的具体实例

* 对象占用独立的内存控件，

来保存这个对象的属性数据

* 独立控制一个对象，

来执行一个方法

引用

=======================================

* 类比成“遥控器”

* 引用变量，保存一个对象的内存地址

* 用引用，可以找到内存中对象的存储空间，

控制或调用这个对象的属性数据和方法

* 引用的特殊值： null

null：空，不保存任何对象的内存地址

1. 属性与方法
属性和方法都是类的成员，用于描述类的特征，每个类都可以有若干个属性、若干个方法。
public class Sample {
}
属性用于描述可以使用值进行量化的特征，通常属性的名称会使用名词，例如：
public class Person {
  String from; // 默认为null
  String name; // 默认为null
  int height; // 默认为0
  float weight; // 默认为0.0f
}
方法用于描述动作或者行为，通常方法的名称是动词，例如：
public class Person {
  void eat() {
    // 东西怎么吃的？
  }
  void run() {
    // 怎么实现跑步的？
  }
}
方法的参数：参数是当执行方法时所需要的条件。
public class Sample {
  void sum(int x, int y) {

  }
}
当方法声明了参数后，调用该方法时，必须提供匹配数据类型、匹配数量、匹配位置的参数值，例如：
public class Test {
  public static void main(String[] a) {
    Sample sample = new Sample();
    // sample.sum(); // 错误
    // sample.sum(1234); // 错误
    // sample.sum("hello"); // 错误
    sample.sum(10, 20); // 正确
  }
}
每一个方法都可以有返回值，如果不需要返回值，则应该声明返回类型为void，如果需要，则声明为对应的类型，且在方法的最后，应该使用return语句返回对应类型的数据，例如：
public class Sample {
  int sum(int x, int y) {
    return x + y;
  }
}
当调用有返回值的方法时，可以获取其返回值，也可以不获取，例如：
public class Test {
  public static void main(String[] args) {
    Sample sample = new Sample();
    sample.sum(10, 15); // 仅调用，不获取值
    int a = sample.sum(3, 7); // 调用，且获取值
  }
}
对于声明为void返回值的方法，也可以使用return语句，但是，return关键字后不可以有任何值，例如：
public class Sample {
  void test() {
    return;
    // System.out.println(); // 无法被执行的语句，错误
  }
}
不管返回值是什么类型，return都应该是方法的最后一条有效语句。
为了便于开发，方法允许重载（Overload），即：在同一个类中允许存在若干个名称相同的方法，但是，这些方法的参数列表必须不同，例如：
public class Sample {
  void run() {}
  void run(int x) {}
  void run(String str) {}
  void run(String str1, String str2, int x) {}
  void run(int x, String str2, String str1) {}
  void run(String str1, int x, String str2) {}
}
参数列表的区别表现为：数量、数据类型、顺序

【测试题】
public class Test1 {
  public static void add1(int i) {
    i++;
  }
  public static void add2(int[] arr) {
    arr[0]++;
  }
  public static void main(String[] args) {
    int x = 10;
    add1(x);
    System.out.println("x=" + x); // 10
    int[] array = { 9, 5, 2, 7 };
    add2(array);
    System.out.println("array[0]=" + array[0]); // 10
  }
}
public class Test2 {
  public static void main(String[] args) {
    int x = 10;
    int y;
    y = x;
    y = 15;
    System.out.println("x=" + x); // 10
    System.out.println("y=" + y); // 15

    int[] arr1 = { 9, 5, 2, 7 };
    int[] arr2;
    arr2 = arr1;
    arr2[0] = 15;
    System.out.println("arr1[0]=" + arr1[0]); // 15
    System.out.println("arr2[0]=" + arr2[0]); // 15
  }
}

构造方法

构造方法是一类特殊的方法，其特征是：
1) 构造方法不允许声明返回值类型，即连void都不可以
2) 构造方法的名称必须与类的名称完全相同
如果类中没有显式的声明构造方法，则编译器会自动的添加公有的、无参数的构造方法，例如以下2段代码是等效的：
public class Person {
}
public class Person {
public Person() {
super();

}

* 新建对象时，执行的一个特殊方法

new Soldier();

new Car();

* 一个类中，必须存在构造方法

* 如果不定义构造方法，

编译器会添加默认构造方法

class A {

public A() {

}

如果开发者显式的声明了构造方法，则编译器不会再自动添加构造方法。
构造方法可以用于创建对象时直接指定对象的某些属性值，例如没有构造方法时：
public class Person {
public String name;
public int age;
}
public class Test {
public static void main(String[] args) {
Person p = new Person();
p.name = "Jack";
p.age = 18;
}
}
如果指定了构造方法：
public class Person {
public String name;
public int age;

public Person(String personName, int personAge) {
name = personName;
age = personAge;
}
}
public class Test {
public static void main(String[] args) {
Person p = new Person("Jack", 18);
}

}

* 构造方法重载（不同参数的多个方法）

class A {

public A() {}

public A(int i) {}

public A(int i,double d) {}

public A(int i,double d,String s) {}

}

构造方法也可以重载，例如：
public class Person {
public String name;
public int age;

public Person() {
}

public Person(String personName, int personAge) {
name = personName;
age = personAge;
}

}

* 构造方法的作用：

*）构造方法用于创建类的对象，例如：

public class Test {
public static void main(String[] args) {
Person p = new Person();

}

*）常见作用，为成员变量赋值

this

======================================

* 两种用法：

*) 引用当前对象

*) 构造方法之间调用

引用当前对象

-----------------------------

*) this 保存当前对象的内存地址

当前对象：正在调用的对象

*) 用 this 调用当前对象的成员

this.name

this.toString()

this.f()

构造方法之间调用

-----------------------------

*) 目的：减少代码重复

*) 一般从参数少的方法，调用参数多的方法，

在参数最多的方法中编写代码，集中处理参数数据

*) this(...) 必须是构造方法首行代码

提问：请详细描述“封装”

封装是面向对象的三大特征（封装、继承、多态）之一。
封装的具体表现是“装”与“封”。
装：将一组相关的属性和方法编写在一个类中。
封：使用相对比较严格的访问权限修饰各个属性，并提供相对宽松的set和get方法。

封装是“装了再封”的过程。

public class Student {

public String name;

private int age;

public String from;

public void setAge(int age) {

if(age >= 12 && age<= 50) {

this.age = age;

}

public int getAge() {

return this.age;

}

public class Test {

public static void main(String[] args) {

Student stu1 = new Student();

stu1.name = "Jack";

stu1.setAge(18);

// stu.age = 1800;

stu1.from = "Beijing";

System.out.println(stu1.getAge());

Student stu2 = new Student();

stu2.setAge(70);

}

方法重载 Overload

=====================================

* 同名不同参

继承

========================================

* 作用：代码重用、代码复用

* 继承了什么：

*) 可见的成员

* 不继承什么：

*) 构造方法

*) 不可见的成员

*) 静态成员

* 单继承：

*) 一个子类只能有一个父类

*) 一个父类，可以有多个子类

* 创建子类对象：

1) 先创建父类对象,执行父类构造方法

2) 再创建子类对象,执行子类构造方法

*) 两个对象绑定在一起，

整体作为一个子类对象

*) 调用成员，先找子类，再找父类

* 创建子类对象，执行父类构造方法

*) 默认执行父类无参构造方法

super();

*) 手动调用父类有参构造方法

super(参数);

* 方法重写 Override

*) 从父类继承的方法，不满足子类需要，

可以在子类中重新编写这个方法

*) 在重写的方法中，

可以调用父类同一个方法的代码

super.toString()

* super 两种用法

*) 重写方法时，调用父类中同一个方法

super.toString()

*) 子类构造方法中，手动调用父类构造方法

super(参数)

*) 必须是首行代码

多态

============================================

* 作用：一致的类型

* 类型转换

*) 向上转型

子类对象转型成父类型

*) 向上转型后，

只能调用父类定义的通用成员

*) 向下转型

已经转为父类型的子类对象，

再转回成子类型

* instanceof

运行期类型识别

*)对真实类型，及其父类型判断，

都得到 true

Shape s = new Line();

s instanceof Line true

s instanceof Shape true

提问：请详细描述多态的概念与特性

----------------------------------------

多态指的是编译期(声明变量时)和运行期(创建对象后)表现为不同的形态(数据类型)。

多态是综合了继承、重写、向上转型、动态绑定等机制的综合应用方式。

多态在代码中的表现可以简单的理解为：当需要父类的对象时，可以使用子类的对象来表示，且，调用方法时，会优先执行子类重写的方法。

Animal a = new Dog();

【相关专业名词】

1. 向上转型：声明时使用父级的类型，但是创建出的对象是子级的类型，例如：

Animal a = new Dog();

对象被向上转型以后，只能调用转型后(父级类别/声明时的类别)的类别的属性、方法，而不能再调用自身特有的属性和方法。

2. 向下转型：将父类对象强制转换为子类的对象，当然，前提是该父类的对象原本就是由子类创建出来的，例如：

Animal a = new Dog();

Dog d = (Dog) a;

或者：

TextView tvTitle = (TextView) findViewById(R.id.tv_title);

3. instanceof关键字：用于判断对象是否归属于某个类，例如：

dog instanceof Dog -> true

dog instanceof Animal -> true

dog instanceof Object -> true

4. 动态绑定：当实现继承关系，且向上转型后，对象被视为父级的类别，理应执行父类的方法，但是，如果子类重写了，则执行子类重写后的方法。

名词解释为：声明期决定了调用父类的方法，但是，在执行过程中，判定结果为执行子类重写的方法，所以称之为动态绑定。

抽象类

=====================================

* 作用：

*) 为子类提供通用代码

*) 为子类提供通用方法的定义

* 半成品类（没画完的图纸）

* 抽象类不能创建对象

* 由子类，来实现抽象类中未完成的方法

* 包含抽象方法的类，必须是抽象类

* 抽象类中，不一定包含抽象方法

提问：
1. 请详细描述“抽象”的概念
抽象使用abstract关键字，该关键字可以修饰方法，这样的方法叫作抽象方法，或者修饰类，这样的类叫作抽象类。
抽象的方法不允许有方法体，抽象的方法不允许存在于普通的类当中。如果抽象方法在类中，则该类必须也是抽象的。
抽象类中的方法并不要求是抽象的，即抽象类中可以没有抽象方法，也可以所有方法都是抽象的。
抽象类被认为是“不完整”的类，所以，抽象类不可以直接创建对象，即不可以使用new语法创建对象，但是，抽象类也是存在构造方法的，且该构造方法会在创建其子类对象时被调用。
由于抽象类本身不可以直接创建对象，所以，在绝大部分应用场景中，可以认为“抽象类就是用于被继承的”。
抽象方法没有方法体，具体的实现应该是由子类来重写的。当某个类继承了抽象类之后，必须重写抽象类中的抽象方法，除非该子类也是抽象的。

public abstract class Animal {
public void eat(){};
public abstract void run();
}

public abstract class Cat extends Animal{
// public abstract void run();
}

public abstract class Dog{}

final

===================================

* 修饰变量、方法、类

* final 变量

*) 变量的值不可变，称为“常量”

*) 基本类型，值本身不可变

*) 引用类型，引用内存地址不可变

final int a = 10;

//a = 100;//不能修改 a 的值

----

final Point a = new Point(2, 3);

a.x = 20;

//a = new Point(5,7);

//a = null

* final 方法

*) 方法不能在子类中重写

* final 类

*) 不能被继承

System

String

提问：3. 请详细描述final关键字的意义
final修饰类不允许被继承
final修饰的方法不可以被重写
final修饰的变量不允许被二次赋值

static

===================================

* 静态

* 静态成员属于类，而不属于实例

* 静态成员可以称为：

类变量

类方法

* 非静态成员可以称为：

实例变量

实例方法

* 一般用类名调用静态成员

A.age

Integer.MAX_VALUE

Math.random()

* 静态方法中，不能调用非静态成员

* 什么时候使用静态

*) 使用原则：能不用就不用

*) 静态是“非面向对象”的语法

*) 使用场景：

*) 共享的数据

*) 工具方法

Math.sqrt()

Math.random()

* 静态初始化块

class A {

static {

在类加载时，只执行一次

}

提问：请详细描述static关键字的作用与特点。

--------------------------------------------

static -> 静态的

被static修饰的成员将最优先加载到内存。

（被static修饰的成员，不能直接访问非static成员），且最后释放内存，即常驻内存，

被static修饰的成员将加载到内存的特定区域，在该区域内，这些成员都是唯一的。

public class Student {

public static int i = 100;

public String name;

public static void main(String[] args) {

i = 999; // 正确的

// name = "Jack"; // 错误的

Student stu = new Student();

stu.name = "Jack"; // 正确的

}

常量

=================================

* static final

static final int MAX_VALUE = 100;

对象创建过程

==========================================

class A {

int v1 = 1;

static int v2 = 2;

static {

...

}

public A() {

...

}

class B extends A {

int v3 = 3;

static int v4 = 4;

static {

...

}

public B() {

...

}

new B()

-----------------------------------------

*) 第一次用到 A, B 两个类

1)加载父类，为它的静态变量分配内存

2)加载子类，为它的静态变量分配内存

3)执行父类静态变量的赋值运算，并执行静态初始化块

4)执行子类静态变量的赋值运算，并执行静态初始化块

*) 每次创建对象时

5)为父类对象分配内存，为它的非静态变量分配内存

6)为子类对象分配内存，为它的非静态变量分配内存

7)执行父类非静态变量的赋值运算

8)执行父类的构造方法

9)执行子类非静态变量的赋值运算

10)执行子类的构造方法

访问控制符

===================================

* 控制一个类或类中的成员的访问范围

类包子类任意

public O O O O

protected O O O

[default] O O

private O

* 选择的原则：

*) 尽量选择小范围

*) public 是与其他开发者的一个契约，

约定公开的东西会保持稳定不变

接口

=======================================

* 作用：

结构设计工具，

用来解耦合

* 接口是极端的抽象类

* 用 interface 代替了 class

* 用 implements 代替了 extends

* 接口中只能定义：

*) 公开的抽象方法

*) 公开的常量

*) 公开的内部类、内部接口

* 一个类，可以同时实现多个父接口

class A implements B,C,D {

}

class A extends B implements C,D,E {

}

* 接口之间继承

interface A extends B,C,D {

}

2. 请详细描述“接口”的概念
接口的组成结构与类基本一致。
接口中的所有成员都是公有(public)的。
接口中的所有属性都是静态常量(static final)。
接口中的所有方法都是抽象的(abstract)
以下2种语法是完全等效的：
public interface USB {
String NAME = "usb-device";
void read();
void write();
}
public interface USB {
public static final String NAME = "usb-device";
public abstract void read();
public abstract void write();
}
类与接口的关系是实现与被实现的关系，使用implements关键字，当类实现了接口，则该类称为该接口的实现类。
同一个类可以同时实现若干个接口，各接口名称之间使用逗号进行分隔，且该类需要实现所有接口中的所有抽象方法，例如：
public class MainActivity extends Activity implements OnClickListener, OnItemClickListener, OnCheckedChangeListener, OnSeekBarChangeListener { }
接口与接口之间也可以继承，使用extends关键字，例如：
public interface InterfaceA extends InterfaceB {}
同一个接口可以同时继承若干个接口，各父级接口名称之间使用逗号进行分隔，例如：
public interface InterfaceA extends InterfaceB, InterfaceC, InterfaceD {}
假设某个类实现了InterfaceA，则该类必须重写InterfaceA、InterfaceB, InterfaceC, InterfaceD中所有的抽象方法。
接口的作用通常是制定一套标准或规范。

内部类

=============================================

* 定义在类内部、方法内部，或局部代码块内的类

* 成员内部类

* 静态内部类

* 局部内部类

* 匿名内部类

成员内部类

成员内部类可以使用任何访问权限修饰符。
内部类可以访问外部类的任意成员，包括私有的。

在没有创建外部类的对象之前，不可以直接创建内部类的对象。

*) 成员内部类实例，

依赖于外部类实例存在

*) 成员内部类中，不能定义静态成员

class A {

class Inner {

}

A a = new A();

Inner inner = a.new Inner();

静态内部类

静态内部类不可以访问外部类中非静态的成员。
静态内部类可以直接创建对象，而不需要依赖于外部类的对象。

class A {

static class Inner {

}

A.Inner inner = new A.Inner();

局部内部类

局部内部类不可以使用任何访问权限修饰符。
使用局部内部类时，需要注意代码的先后顺序。

在局部内部类中，不可以直接访问局部变量，如果一定需要访问，可以使用final修饰该局部变量，或者将局部变量声明为全局变量(类的属性)。

class A {

Weapon f() {

class Inner implements Weapon {

...

}

Inner inner = new Inner();

return inner;

}

A a = new A();

Weapon w = a.f();

w.kill();

匿名内部类

直接创建已知的类的子类对象，或者已知的接口的实现类对象，而创建时，并不体现子类/实现类的名称，即创建出来的对象的类名是未知的

Weapon w = new Weapon() {...};

提问：请详细描述内部类的种类和各种内部类的语法特征。

-----------------------------------

把某个类定义在其它类的内部，则称之为内部类。

内部类可以访问外部类的所有成员(静态内部类除外)，无论这些成员是使用哪种访问权限修饰符进行修饰的。

1. 成员内部类

在类(外部类)的内部，且与外部类的成员是“同一级别”的。

public class OutterClass {

private int i;

private void run() {

int x;

}

private void test() {

int y;

}

public class InnerClass {

}

成员内部类可以使用任何访问权限修饰符。

成员内部类不可以在外部类的外部直接创建对象。

2. 局部内部类

内部类的“定位”类似于局部变量，即声明在方法内部的类，则称之为局部内部类。

public class MainActivity extends Activity {

public Button btn;

public int a;

public void onCreate(final int i) {

final int x = 100;

class InnerClass {

public void test() {

System.out.println(x);

System.out.println(i);

System.out.println(a);

}

InnerClass ic = new InnerClass();

btn.setOnClickListener(ic);

}

局部内部类不可以使用任何访问权限修饰符。

局部内部类的定义、对象的创建，必须符合方法中代码的执行逻辑。

局部内部类不可以直接访问局部变量(方法的参数等效于局部变量)，如果一定需要访问，则需要使用final对局部变量进行修饰，使之成员常量，或者，将局部变量提升为成员变量。

3. 静态(成员)内部类

使用static修饰的成员内部类，称之为静态内部类。

public class OutterClass {

public int x = 5;

public static int y = 100;

public static class InnerClass {

public void run() {

// System.out.println(x); // 错误

System.out.println(y); // 正确

}

静态内部类只能访问外部类的静态成员，而不能直接访问外部类的非静态成员。

静态内部类可以在任何位置(包括外部类的外部)直接创建对象。

4. 匿名内部类

直接创建已知的类的子类的对象(或者已知的接口的实现类的对象)，则该对象的类型就是匿名内部类，顾名思义，该类型并没有名称。

public class OutterClass {

public void run() {

new OnClickListener() {

public voic onClick() {

}

};

}

提问：
1. 请详细描述“单例模式”
单例模式表现为：实例唯一，即某个类的对象最多只允许存在1个。
>> 步骤1：普通的类是可以随意创建若干个对象的：
public class King {

}
public class Test {
public static void main(String[] args) {
King k1 = new King();
King k2 = new King();
}
}
>> 步骤2：将构造方法私有化，则在其它类中不可以创建King的对象
public class King {
private King() {
}
}
public class Test {
public static void main(String[] args) {
// King k1 = new King();
// King k2 = new King();
}
}
>> 步骤3：在King的内部仍然可以调用被私有化的构造方法，则可以创建公有的getInstance()方法，用于获取King的对象
public class King {
private King() {
}
public King getInstance() {
return new King();
}
}
>> 步骤4：由于在类的外部不可以创建King的对象，则不可以调用getInstance()方法，所以，必须将该方法修饰为static
public class King {
private King() {
}
public static King getInstance() {
return new King();
}
}
public class Test {
public static void main(String[] args) {
King k1 = King.getInstance();
King k2 = King.getInstance();
}
}
>> 步骤5：以上完成了King的对象的创建过程的限制，但是并没有实现单例！则应该在King的内部，声明King类型的对象，并使用static修饰，保证该对象是唯一的
public class King {
private static King king;
private King() {
}
public static King getInstance() {
return new King();
}
}
>> 步骤6：调整getInstance方法：
public class King {
private static King king;
private King() {
}
public static King getInstance() {
if(king == null) {
king = new King();
}
return king;
}
}

2. 请详细描述“工厂模式”
工厂模式是用于生产对象的，即使用工厂类控制产品类的创建过程。
public class Fruit {
}

// Apple类去掉public修饰符，且与Fruit、FruitFactory在同一个包中，保证FruitFactory对Apple有访问权限
class Apple extends Fruit {
}

class Orange extends Fruit {
}

public class FruitFactory {
public static Fruit newInstance(int type){
Fruit f = null;
switch(type){
case 1:
f = new Apple();
break;

case 2:
f = new Banana();
break;
}
return f;
}
}

秒客网

Java学习笔记之面向对象

相关文章