Java面向对象的三大特性

Java面向对象的三大特性

1. 继承

继承的概念

1.继承是类与类之间的关系

2.使用已存在的类定义作为基础建立新类

3.作为基础的类一般称为父类（基类），创建的新类称为子类（派生类）

4.新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能先择性地继承父类

5.满足A is a B 的关系就可以形成继承关系

继承的实现

在Java中使用extends关键字来实现类的继承，同时需要注意的是在Java中只能继承一个父类

public class Animal {
	//公共的属性和方法
}
//编写子类，继承父类
public class Dog extends Animal {
	//子类特有的属性和方法
}
public class Cat extends Animal {
	//....
}

方法重写

1.@Override 用于检测该方法是否为重写

2.方法重写出现在有继承关系的子类中，以下几个要素都要与父类继承的方法相同

 返回值类型
 方法名
 参数类型、顺序、个数

 @Override
    public void call(){
        System.out.println("小🐱的叫声：喵喵喵～～～");
    }

方法重载

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。最常用的地方就是构造器的重载。

重载规则

1.被重载的方法必须改变参数列表(参数个数或类型不一样)；

2.被重载的方法可以改变返回类型；

3.被重载的方法可以改变访问修饰符；

4.被重载的方法可以声明新的或更广的检查异常；

5.方法能够在同一个类中或者在一个子类中被重载
。
6.无法以返回值类型作为重载函数的区分标准。

public class Overloading {
    public int test(){
        System.out.println("test1");
        return 1;
    }
 
    public void test(int a){
        System.out.println("test2");
    }   
 
    //以下两个参数类型顺序不同
    public String test(int a,String s){
        System.out.println("test3");
        return "returntest3";
    }   
 
    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }   
 
    public static void main(String[] args){
        Overloading o = new Overloading();
        System.out.println(o.test());
        o.test(1);
        System.out.println(o.test(1,"test3"));
        System.out.println(o.test("test4",1));
    }
}

final 关键字

修饰符：该类不允许被继承

修饰方法：该方法不允许被重写

修饰成员属性：赋值必须在实例对象之前
赋值过程：

1、定义直接俄初始化
2、构造代码块内
3、构造方法内

 1 public class B extends A {
 2 
 3     public static void main(String[] args) {
 4 
 5     }
 6 
 7     public void getName() {
 8         
 9     }
10 }
11 
12 class A {
13 
14     /**
15      * 因为private修饰，子类中不能继承到此方法，因此，子类中的getName方法是重新定义的、
16      * 属于子类本身的方法，编译正常
17      */
18     private final void getName() {
19         
20     }
21 
22     /* 因为pblic修饰，子类可以继承到此方法，导致重写了父类的final方法，编译出错
23     public final void getName() {
24     
25     }
26     */
27 }

修饰局部变量：只要在使用之前进行赋值即可，一旦赋值不允许被修改

基本数据类型变量：初始赋值之后不能改变

引用类型变量：初始化之后不能再指向另一个对象

super关键字

• 我们使用super关键字在子类中来表示对父类对象的引用
• 访问父类成员方法super.方法名();
• 访问父类属性super.属性();
• 访问父类构造方法super.();

Object类

Object是多有类的父类

一个没有使用extends关键字明确标识继承关系，则默认继承Object类（包括数组）

Java中的每一个类都可以使用Object类中定义的方法

toString()方法

输出对象时，默认会直接调用类中toString()

继承Object中的toString方法时，输出对象的字符串表示形式：类型信息@哈希码

子类可以通过重写toString方法的形式，改变输出的内容以及表现形式

public class Test {
    public static void main(String args[]) {
        String Str = new String("WWW.RUNOOB.COM");

        System.out.print("返回值 :" );
        System.out.println( Str.toString() );
    }
}

equals() 方法

继承Object中的equals方法时，比较的是两个引用是否指向同一个对象
子类可以通过重写equals方法的形式，改变比较的内容

访问修饰符的分类及使用

访问修饰符
private
默认
protected
public

2.封装

封装的实现

封装的概念
	将类的某些信息隐藏在类内部，不允许外部程序直接访问
	通过该类提供的方法来实现对隐藏信息的操作和访问
	隐藏对象的信息
	流出访问的接口
封装的特点
	1.只能通过规定的方法访问数据
	隐藏类的实例细节，方便修改和实现
封装的代码实现
	1.修改属性的可见性：设为private
	2.创建get ter / set ter 方法：设为public用于属性的读写
	在get ter / set ter 方法中加入属性控制语句：对属性的合法行进行判断**

private String name;//定义一个名
private int age;//定义年龄
private String sex;//定义性别

使用包进行类管理

跨包进行类的调用
	使用* 通配符来加载包下的所有类
	加载需要的类
	使用类全名进行跨包调用类

package xxxx;//包名

static 关键字

类对象共享
类加载时产生，销毁时释放，生命周期长

3.多态

多态存在的三个必要条件

继承
重写
父类引用指向子类对象

向上转型

向上转型即父类引用指向子类实例

public class Test {
    public static void main(String[] args) {
        Animal a1 = new Animal();
        //向上转型
        Animal a2 = new Cat();//将Animal类转型成Cat类
        Animal a3 = new Dog();//将Animal类转型成Dog类
      
        boolean flag = a2 instanceof Animal;
        System.out.println(flag);

    }
}

instanceof 运算符

//用于判断 obj 是否是 Classname 的实例或者是派生类实例
boolean  flag = obj instanceof Classname;

向下转型

向下转型（强制类型转换）即子类引用指向父类实例，需要强制类型转换

public class Test {
    public static void main(String[] args) {
        Animal a1 = new Animal();
        //向上转型
        Animal a2 = new Cat();
        Animal a3 = new Dog();

        //向下转型
        Cat cat = (Cat) a2;//将Cat类转型成Animal类
        Dog dog = (Dog) a3;//将Dog类转型成Animal类
      
        boolean flag = a2 instanceof Animal;
        System.out.println(flag);

    }
}