Java自学笔记（二）：面向对象

学习网站：https://www.runoob.com/java/java-tutorial.html

目录

• 类和对象基本构造和访问
• 继承
• 重写(Override)与重载(Overload)
• 多态
• 抽象类和抽象方法
• 封装
• 接口
• 包package

类和对象基本构造和访问

1. 对象构造方法，相当于初始化对象。至少需要调用一个构造方法

public class Puppy{
 String a;
 public Puppy()  //最简单的构造方法
 {}
 public Puppy(string x){
  a=x;
 }
}

2. 创建对象，对象名+new+构造方法

Puppy P1 = new Puppy();
Puppy P2 = new Puppy("abc");

3. 访问对象的属性和方法（对象名.属性名/方法()）

继承

1. 基本概念：子类重用父类的非私有属性和方法
2. 格式：

class A{ }
class B extends A{ }

用implements继承接口：

interface A{ }
class B implements A{ }

关键词this, super：

this: 子类
super: 父类

3. 继承类型
   • 单继承
   • 多重继承
     
   • 不同类继承同一类
     
   • 多继承不支持
     
4. 特征
   • 可继承的父类属性和方法应是非private的
   • 子类也拓展自己的属性和方法，也可改写父类的方法
   • 用final修饰的类无法被继承，用final修饰的方法是不能被子类所重写
5. 构造器
   父类自身含有有参或无参构造器，子类可以显式或隐式调用。若父类有有参构造器，子类需要用super(xxx)来调用其有参构造函数；若父类有无参构造器，子类不需要特别写，系统可以自动调用其无参构造函数。

重写(Override)与重载(Overload)

1. 区别：重写是子类重写改写父类的方法，重载是同一个类中对同一个方法的不同实现

区别点	重写	重载
参数列表	不能变	必须变
返回类型	不能变	可变可不变
异常抛出	可减少或删除，修改的话不能有新的异常或比比其更广的异常	可变可不变
访问	不能是比父类更严格的限制（可以降低限制）	可变可不变变

2. 重写的规则

   • 外壳不变，只变内部
   • 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法
   • 子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法
   • 构造方法不能被重写

3. 重载的规则

   • 参数列表必须独一无二，单单改变返回类型是不行的
   • 最常用的地方就是构造器的重载

多态

1. 概念：是同一个行为具有多个不同表现形式或形态的能力
2. 三种必要条件
   • 继承
   • 重写
   • 父类引用指向子类对象

Parent p = new Child();

3. 实现方法
   • 重写
   • 接口（各方法的集合，没有具体实现）
   • 抽象类和抽象方法
4. 例子

abstract class Animal{
	abstract void say();
}
class Cat extends Animal{
	void say() {
		System.out.println("我是猫"); 
	}
}
class Dog extends Animal{
	void say() {
		System.out.println("我是狗"); 
	}
}
public class Puppy { 
	   
    public static void main(String[] args) {
    	Animal A = new Cat();
    	Animal B = new Dog();
        A.say();
        B.say();
    }
}

抽象类和抽象方法

1. 抽象类

(修饰词) abstract class A() {xxx}

- 抽象类可以作为只给出类的框架，而由继承的子类来重写扩充类
- 抽象类不能被实例化，只能被继承
- 抽象类不一定包含抽象方法，但是包含抽象方法的类一定要是抽象类

2. 抽象方法

(修饰词) abstract (返回值) function();  //只有()，没有{xxx}

- 子类必须重写抽象类的抽象方法，或是子类也是抽象类的话就不用重写
- 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法

封装

1. 封装（Encapsulation）是将某些private的值隐藏起来，用接口函数来实现访问和修改private值
2. 例子

public class Puppy{
	private int age;
	public Puppy() { }
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public static void main(String[] args) {
		Puppy P = new Puppy();
		P.setAge(12);
		int result = P.getAge();
		System.out.println(result);
	}
}

接口

1. 定义：接口（Interface）是一个抽象类，是抽象方法的集合。
   • 实现接口：除非是抽象类，否则实现（implements）接口的类要定义接口中的所有方法
   • 继承接口：由另一个接口继承（extends）父接口

interface Animal {
	   public void eat();
}
interface Cat extends Animal{
	public void meow();
}
public class Puppy implements Cat{
	public Puppy() { }
	public void eat() {System.out.println("eat");}
	public void meow() {System.out.println("meow");}
	public static void main(String[] args) {
		Puppy P = new Puppy();
		P.eat();
		P.meow();
	}
}

2. 接口特性
   • 接口没有构造方法
   • 接口中所有的方法必须是抽象方法（隐式抽象，隐式指定为public abstract而不用明写）
   • 接口不能包含成员变量，除了 static 和 final 变量（隐式的指定为 public static final 变量）
   • 接口支持多继承（类不支持多继承）
   • 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，但是JDK 1.8 以后

包package

- 一些常见的java包：java.lang-打包基础的类；java.io-包含输入输出功能的函数
- 导入包：import xxx