Java面向对象三大特性、抽象和接口总结

Java面向对象三大特性、抽象和接口总结

一、面向对象三大特性

面向对象语言：是一种以对象形式作为基本程序结构 的设计语言。也就是用语言描述问题是在对象形式上来建立的。它具有封装性、继承性和多态性这3大特性；而对象的实现是通过实例化class类实现的；Java就属于面向对象语言的一种；

封装性：

封装性起到保护类的作用；主要将类中的某些信息进行隐藏(private)，防止其他类直接调用或修改，而导致破坏类的信息状态；类里面的隐藏信息一般通过自定义的setter/getter成员方法进行修改和访问；

封装方式：通过private,protected,public修饰符来改变访问权限，以达到封装性的效果；

1. private（私人的）只限于当前类访问；
2. protected（受保护的）只限于同一包下面本身类和子类访问；
3. public（公共的）任何包都可以访问；

如果没写修饰符，则统一默认public修饰符访问权限；

public class TestOne{
    private String name; //private修饰符定义改属性
    public void setName(name){//通过setName修改name属性
        this.name=name;
    }
    public String showName(){//通过showName访问name属性
        return this.name;
    }
}

继承性：

继承方式：通过extends关键字实现类和类之间的继承性；

继承性主要为了程序的可扩展性/复用性，也就是在Java中，将公共的部分代码抽离成一个父类，然后其他子类可以继承该父类，那么子类就拥有了父类的特征(属性)和行为(方法)；但是继承性不要滥用，它会提高代码的耦合度，不利于代码维护；所以继承是把双刃剑；记住一份好的项目代码的特性是高内聚低耦合的；

一、基本的继承关系

//定义类AA
public class ClassAA {
    private String name;    //姓名
    private String wType; //职业类型
    public ClassAA(String name,String wType){
        this.name=name;
        this.wType=wType;
    }
    public void showInfo(){
        System.out.println(this.name+"是一名"+this.wType);
    }
}
//定义类A并extends关键字继承ClassAA
public class ClassA extends ClassAA {
    public ClassA(String name,String wType){
        super(name,wType);
    }
    public static void main(String[] args){
        ClassA a_obj=new ClassA("张三","前端开发程序猿");
        a_obj.showInfo();
    }
}

二、继承性结构展示和多种实现

图一展示的是继承的结构图；继承性一般是单向性、多重性;

1. 单向性：一个子类有一个父类，方向是从父类流向子类；毕竟有父亲才有儿子；
2. 多重性：类似于家族谱，继承可以拥有父类、父(父类)、…(父类)等结构；

图二展示的是继承的多种实现方式，同时重复了图一的单向性、多重性；(图二来自菜鸟教程)

总结：在Java中没有多继承的概念，Java属于单继承，也就是一个子类只能有一个父类；但是不同的子类可以继承同一个父类。也就是之类之间可以有兄弟。

多态性：

多态性是建立在继承性上面的，也就是说一个父类方法可以衍生多种不同行为或表现的方法；俗语中的：龙生九子，九子不同。就有多态性和继承的概念；满足多态性必须满足“继承”、“重写”、“父类引用子类对象”这3个条件，缺一不可哦；继承就不啰嗦了。

1. 重写：是指重写父类方法，以满足自身的特征方法。例如，再手机分辨率一致，屏幕大小不一致的前提，同时还需返回屏幕大小信息，那么就需要重写父类方法。（注意：重写一般只针对于方法，属性重写会报错）;代码如下所示：

//Phone只设置屏幕分辨率信息
//@Override装饰器表示重写
pulic class Phone{
    private String sInfo; //屏幕信息
    public void showSInfo(){ //显示屏幕信息
        System.out.print("1900x1080分辨率显示屏");
    }
}
//例如：PhoneA屏幕大小时5.0英寸
public class PhoneA extends Phone {
	@Override
    public void showSInfo(){
        String sszie="5.0"; //设置手机屏幕大小
        System.out.print("手机A屏幕大小:"+ssize+";1900x1080分辨率显示屏");
    }
}
//例如：PhoneB屏幕大小时6.0英寸
public class PhoneB extends Phone {
	@Override
    public void showSInfo(){
        String sszie="5.0"; //设置手机屏幕大小
        System.out.print("手机B屏幕大小:"+ssize+";1900x1080分辨率显示屏");
    }
}

2. 父类引用子类对象：是一种“向上转型”的方式，使用父类类型来引用子类实例化的对象；该引用只能调用父类本身的方法和属性，或者可以调用子类对象中重写父类的方法；

//定义父类Parent
public class Parent {
	public void showName() {
		System.out.println("我是父类Parent");
	}
}
//定义子类Child
public class Child {
	public void showInfo() {
		System.out.println("信息查询");
	}
	@Override
	public void showName() {
		System.out.println("数据改变了");
	}
	public static void main(String[] args) {
	    //childObj属于父类Parent类型，所以只能调用父类本身属性和方法
	    //或者调用子类重写的父类方法
	    //不能直接调用当前子类的属性和方法
		Parent childObj=new Child(); //向上转型
		//Child newObj=(Child) childObj; //强制向下转型
		childObj.showName();
		childObj.showInfo(); //导致报错，不能正常编译
	}
}

二、抽象和接口的区别

抽象类基本概念

用关键字abstract声明的类或者包含抽象方法的类成为抽象类（抽象方法没有方法体）。抽象类主要是被其他类继承，也许有人疑问，继承用普通类就好了，干嘛要抽象类。抽象类关键在于“抽象”，在面向对象语言中，所有的对象是实例化类实现的，但是如果有一个类没有具体的信息，那就应该将它抽象出来（抽象类），该类也就不能被实例化，所以抽象类一般作为不能实例化的基类（第一代）；抽象类里面可以包含成员属性和成员方法，与其他类并无什么不一致；代码如下：

//接口类Person
abstract class Person{
    private String name; //成员属性name
    abstract void showName(); //抽象方法——无方法体
    public void setName(String name){ //成员方法
        this.name=name;
    }
    public String getName(){
        return this.name;
    }
}
//普通类Student继承接口类Person
class Student extends Person{
   @Override
	void showName() {
		// TODO Auto-generated method stub
		System.out.println(this.getName());
	}
	public static void main(String[] args) {
		Two two=new Two();
		two.setName("我是学生");
		two.showName();
	}
}

抽象类特点总结

1. 用abstract关键字声明的类，并且包含抽象方法（无方法体）；
2. 抽象类可以拥有成员属性和成员方法；
3. 抽象类不能被实例化，一般作为基类；
4. 抽象类一般用来继承，抽象化不具体的类；
5. 普通类通过extends关键字实现抽象类的继承，只能单继承；
6. 继承抽象类的子类必须实现抽象方法；

接口的基本概念

用关键字interface修饰的类称为接口类，写法如下：

[public] interface InterFaceName{} //public可以不用写，因为接口默认是public

接类口中只能包含接口方法（接口方法没有方法体），不能有其他成员属性和成员方法，注意接口类和接口方法的访问修饰符只能是public。接口是为了实现Java没有多继承的尴尬，同时可以抽象和约束普通类的行为。代码如下：

//接口
interface UserInterface{ //接口类
    void show(); //接口方法showName——无方法体
	default public void setName() { //在java8及以上版本，可以通过default关键字在接口类中实现成员方法
		System.out.println("接口类中default关键字成员方法执行");
	};
}
//普通类UserInfo实现接口类UserInterface
class UserInfo implements UserInterface {
	@Override
	public void show() {
		// TODO Auto-generated method stub
		System.out.println("重写接口类中接口方法show执行");
	}
	public static void main(String[] args) {
		UserInfo two=new UserInfo();
		two.setName();
		two.show();
	}
}

接口类特点总结

1. 用interface关键字声明的类，并且包含接口方法（无方法体）；
2. 接口类中不能拥有成员属性和成员方法，但是通过default关键字可以拥有成员方法（限于java8及以上版本）；
3. 接口一般作为普通类行为的约束和抽象；
4. 普通类通过implements（实现）实现接口类，可以以逗号隔开，实现多接口实现，解决java中不能多继承的尴尬；