2.面向对象进阶

Mr.Tong...

Java知识体系
面向对象

Java知识体系
面向对象

大约 11 分钟

1. 继承

1. 继承的概念

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

生活中的继承：

2. 继承的格式

在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：

class 父类 {
}
 
class 子类 extends 父类 {
}

3. 为什么要继承

降低代码的重复冗余，提到代码复用率，达到高可用，再提高开发效率上功不可没。

比如说下面有企鹅和老鼠类，要求如下：

企鹅：属性（姓名，id），方法（吃，睡，自我介绍）
老鼠：属性（姓名，id），方法（吃，睡，自我介绍）

企鹅类：

public class Penguin { 
    private String name; 
    private int id; 
    public Penguin(String myName, int  myid) { 
        name = myName; 
        id = myid; 
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是"         + id + "号" + name + "."); 
    } 
}

老鼠类：

public class Mouse { 
    private String name; 
    private int id; 
    public Mouse(String myName, int  myid) { 
        name = myName; 
        id = myid; 
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是"         + id + "号" + name + "."); 
    } 
}

很容易发下代码存在重复了，都具有相同的吃、睡和自我介绍的方法，对于公共的方法可以建立在公共类上继承即可，如下：

公共父类：

public class Animal { 
    private String name;  
    private int id; 
    public Animal(String myName, int myid) { 
        name = myName; 
        id = myid;
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是"         + id + "号" + name + "."); 
    } 
}

这个Animal类就可以作为一个父类，然后企鹅类和老鼠类继承这个类之后，就具有父类当中的属性和方法，子类就不会存在重复的代码，维护性也提高，代码也更加简洁，提高代码的复用性（复用性主要是可以多次使用，不用再多次写同样的代码）继承之后的代码：

继承后的企鹅类：

public class Penguin extends Animal { 
    public Penguin(String myName, int myid) { 
        super(myName, myid); 
    } 
}

继承后的老鼠类：

public class Mouse extends Animal { 
    public Mouse(String myName, int myid) { 
        super(myName, myid); 
    } 
}

4. 继承类型

需要注意的是 Java 不支持多继承，但支持多重继承。

5. 继承的特性

子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

6. 继承关键字

继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承 Object（这个类在 java.lang 包中，所以不需要 import）祖先类。

在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

7. super 与 this 关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this关键字：指向自己的引用。

class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}
 
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}
 
public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();
    Dog d = new Dog();
    d.eatTest();
  }
}

结果：

animal : eat
dog : eat
animal : eat

8. final 关键字

final 可以用来修饰变量（包括类属性、对象属性、局部变量和形参）、方法（包括类方法和对象方法）和类。含义为 "最终的"。

使用 final 关键字声明类，就是把类定义定义为最终类，不能被继承，或者用于修饰方法，该方法不能被子类重写：

声明类：

final class 类名 {//类体}

声明方法：

修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

注： final 定义的类，其中的属性、方法不是 final 的。

9. 构造器

子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

class SuperClass {
  private int n;
  SuperClass(){
    System.out.println("SuperClass()");
  }
  SuperClass(int n) {
    System.out.println("SuperClass(int n):"+n);
    this.n = n;
  }
}
// SubClass 类继承
class SubClass extends SuperClass{
  private int n;
  
  SubClass(){ // 自动调用父类的无参数构造器
    System.out.println("SubClass");
  }  
  
  public SubClass(int n){ 
    super(300);  // 调用父类中带有参数的构造器
    System.out.println("SubClass(int n):"+n);
    this.n = n;
  }
}
// SubClass2 类继承
class SubClass2 extends SuperClass{
  private int n;
  
  SubClass2(){
    super(300);  // 调用父类中带有参数的构造器
    System.out.println("SubClass2");
  }  
  
  public SubClass2(int n){ // 自动调用父类的无参数构造器
    System.out.println("SubClass2(int n):"+n);
    this.n = n;
  }
}
public class TestSuperSub{
  public static void main (String args[]){
    System.out.println("------SubClass 类继承------");
    SubClass sc1 = new SubClass();
    SubClass sc2 = new SubClass(100); 
    System.out.println("------SubClass2 类继承------");
    SubClass2 sc3 = new SubClass2();
    SubClass2 sc4 = new SubClass2(200); 
  }
}

------SubClass 类继承------
SuperClass()
SubClass
SuperClass(int n):300
SubClass(int n):100
------SubClass2 类继承------
SuperClass(int n):300
SubClass2
SuperClass()
SubClass2(int n):200

3. 封装-private

在面向对象程式设计方法中，封装（Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。

封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

1. 封装的优点

良好的封装能够减少耦合。
类内部的结构可以自由修改。
可以对成员变量进行更精确的控制。
隐藏信息，实现细节。

2. 封装的步骤

使用private修改属性的可见性来限制对属性的访问。

public class Person {
    private String name;
    private int age;
}

被private修饰后，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。

对封装的属性提供对外的公共方法访问get和set方法，用于对私有属性的访问，例如：

public class Person{
    private String name;
    private int age;
    
    public int getAge(){
      return age;
    }
    public String getName(){
      return name;
    }
    public void setAge(int age){
      this.age = age;
    }
    public void setName(String name){
      this.name = name;
    }
}

采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。

调用封装的属性和方法

public class RunEncap{
   public static void main(String args[]){
      Person p = new Person();
      p.setName("James");
      p.setAge(20);
      System.out.print("Name : " + p.getName()+ " Age : "+ p.getAge());
    }
}

3. this

在Java基础中，this关键字是一个最重要的概念。使用this关键字可以完成以下的操作：

调用类中的属性
调用类中的方法或构造方法
表示当前对象

4. static

static表示“静态”的意思，可以用来修饰成员变量和成员方法。static的主要作用在于创建独立于具体对象的域变量或者方法。

简单理解：被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。并且不会因为对象的多次创建而在内存中建立多份数据

静态成员在类加载时加载并初始化。
无论一个类存在多少个对象 , 静态的属性, 永远在内存中只有一份( 可以理解为所有对象公用 )
在访问时：静态不能访问非静态 , 非静态可以访问静态 !

5. 代码块

普通代码块

在执行的流程中出现的代码块，我们称其为普通代码块。

构造代码块

在类中的成员代码块，我们称其为构造代码块，在每次对象创建时执行，执行在构造方法之前。

静态代码块

在类中使用static修饰的成员代码块，我们称其为静态代码块，在类加载时执行。每次程序启动到关闭，只会

执行一次的代码块。

同步代码块

在后续多线程技术中学习。

面试题：

构造方法与构造代码块以及静态代码块的执行顺序：

静态代码块 --> 构造代码块 --> 构造方法

6. 包

包其实如同文件夹一样，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。同时包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

通过import 关键字导入

import 包名.类名;

7. 权限修饰符

8. main方法详解

public static void main(String args[])

以上的各个参数的含义如下：

public：表示公共的内容，可以被所有操作所调用
static：表示方法是静态的，可以由类名称直接调用。java StaticDemo09
void：表示没有任何的返回值操作
main：系统规定好的方法名称。如果main写错了或没有，会报错：NoSuchMethodError: main
String[] args：字符串数组，接收参数的

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

所有的参数在执行类的时候以空格进行分割。

比如参数为 10 1 2 3 4 5 6 7。

但是，如果现在我要输入的是以下几种参数""hello world"、"hello vince"、"hello mjw"。

因为以空格分割，所以以上的三组参数会当做六组参数输入，那么此时如果要想完成有空格的内容输入，则参数需

要使用""括起来

9. 单例设计模式

指一个类只有一个实例，且该类能自行创建这个实例的一种模式。单例设计模式是我们学习的第一个设计模式，也是比较重要的一个设计模式，单例设计模式会伴随这你的开发生涯，不管你是初级程序员，还是以后晋级到高级程序员，你都会接触到单例设计模式，今天，我们就学习单例设计模式的两种实现方式。

懒汉式：随着类的加载在内存中对象为null，当调用 getInstance 方法时才创建对象（延迟加载）
饿汉式：随着类的加载直接创建对象（推荐开发中使用）

单例设计模式的实现步骤：

保证一个类只有一个实例，实现方式：构造方法私有化
必须要自己创建这个实例，实现方式：在本类中维护一个本类对象（私有，静态）
必须向整个程序提供这个实例，实现方式：对外提供公共的访问方式（getInstance方法，静态）

懒汉式实现如下：

class Single{
	private Single(){}
	private static Single s1 = null;
	public static Single getInstance(){
		if(s1 == null){
			s1 = new Single();
		}
		return s1;
	}
}

饿汉式实现如下：

class Single2{
	private Single2(){}
	private static Single2 s = new Single2();
	public static Single getInstance(){
	return s;
	}
	void print(){
	System.out.println("Hello World!");
	}
}

你认为这篇文章怎么样？

昵称

邮箱

网址

按正序
按倒序
按热度

2.面向对象进阶

# 1. 继承

# 1. 继承的概念

# 2. 继承的格式

# 3. 为什么要继承

# 4. 继承类型

# 5. 继承的特性

# 6. 继承关键字

# 7. super 与 this 关键字

# 8. final 关键字

# 9. 构造器

# 3. 封装-private

# 1. 封装的优点

# 2. 封装的步骤

# 3. this

# 4. static

# 5. 代码块

# 6. 包

# 7. 权限修饰符

# 8. main方法详解

# 9. 单例设计模式