Java三大特征（封装，继承，多态）

Java的三大特征是什么呢？

 一、封装
 二、继承
 三、多态

一、封装

1.1、什么是封装？

 封装就是把同一类事物的共性（包括属性和方法）归到同一类中，并尽可能的隐藏
对象的内部实现细节。比如说，狗的属性包括品种，体重等，行为包括吃饭，睡觉等。

1.2、为什么要封装即封装的意义

1.2.1、为什么要封装

   能屏蔽方法的复杂性，比如只要知道方法的参数类型就可以使用方法，再说降低
 模块之间的耦合性，就是模块之间的联系，让之相互独立，能提高系统的健壮性，
 就是不容易崩溃，相应的对应的方法也变得很多。

1.2.2、封装的意义

1. 对外提供可调用的、稳定的功能；
2. 封装容易变化的、具体的实现细节，外界不可访问，这样的意义在于：
a.降低代码出错的可能性，便于维护。
b.当内部细节改变时，只要保证对外功能定义不变，其他的模板就不会因此改变。

1.3、封装实现的步骤

一、首先通过private私有化变量，限制对类属性的访问

package feature;

public class Dog{
	private int age;
	private String name;
	private String sex;
}

二、在Dog类中通过set和get方法设置对每个属性对外访问接口，外部需要改变类的属性，需要通过这些公共public的方法

	public int getAge(){
		return age;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public String getSex() {
		return sex;
	}
	
	public void setSex(String sex) {
		this.sex = sex;
	}

三、创建一个Dogs类，创建Dog类的对象，通过对象设置封装类的属性，然后通过get方法获取这些属性

class Dogs{
	public static void main(String[] args) {
		Inherit s = new Inherit();
		s.setAge(12);
		s.setName("xiaoming");
		s.setSex("母");
		System.out.print("年龄：" + s.getAge() + " 名字：" + s.getName() + " 性别：" + s.getSex());
		
	}
}

结果为：年龄：12 名字：xiaoming 性别：母

二、继承

2.1、什么是继承

1.多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中
2.那么多个类无需再定义这些属性和行为，只要继承那个类即可。
3.多个类可以称为子类，单独这个类称为父类、超类或者基类。
4.子类可以直接访问父类中的非私有（private之外）的属性和行为。

2.2、继承有什么有优点

  提高代码的复用性
  让类与类之间产生关系
  不需要重复代码

2.3、继承的特点

Java中的一个类只能继承一个类，不能继承多个类

//一个类只能有一个父类，不可以有多个父类。
class Demo extends Demo1{} //ok
class Demo extends Demo1,Demo2...//error

Java支持多重继承

class A{}
class B extends A{}
class C extends B{}

2.4、extends关键字

子类想要继承父类，必须使用extends关键字才能实现

class animal {
    private String name;
    private String sex;
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name=name;
    }
    public String getSex()
    {
        return sex;
    }
    public void setSex(String sex)
    {
        this.sex=sex;
    }
}
class Dogs extends animal{ 
}
public class Dog{
    public static void main(String[] args)
    {
    	Dogs Dog=new Dogs();
    	Dog.setName("花花");
    	Dog.setSex("女");
        System.out.println("姓名："+Dog.getName()+"  性别："+Dog.getSex());
    }
}

 结果为：姓名：花花 性别：女

2.5、super和this关键字

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

this关键字：指向自己的引用，访问本类内容。

以下super和this关键字的三种用法为引用此博主的想法https://blog.csdn.net/v02040212/article/details/108837045

super关键字的用法有三种：

a. 在子类的成员方法中，访问父类的成员变量。
b.在子类的成员方法中，访问父类的成员方法
c.在子类的构造方法中，访问父类的构造方法

this关键字的用法有三种：

1.在本类的成员方法中，访问本类的成员变量。
2. 在本类的成员方法中，访问本类的另一个成员方法
3.在本类的构造方法中，访问父类的另一个构造方法

在第三种用法当中要注意：
A、this(…)调用也必须是构造方法的第一个语句，唯一一个
B、super和this两种构造调用，不能同时使用

public class Persons {
    public static void main(String[] args) {
        Student s = new Student("Xiao Ming", 12, 89);
    }
}

class Person {
    protected String name;
    protected int age;
    
//构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

class Student extends Person {
    protected int score;

    public Student(String name, int age, int score) {
        this.score = score;
    }
}

以上代码将会报错，以上就是Student的构造方法无法调用Person的构造方法。
所以我们就得借助super关键字了。

    public Student(String name, int age, int score) {
    super();
        this.score = score;
    }

如果只是这样，同样会报错，因为Person的构造方法中有参数

    public Student(String name, int age, int score) {
    	super(name,age);
        this.score = score;
    }

 这样子就可以正常编译了

三、多态

多态是指针对某个类型的方法调用，其真正执行的方法取决于运行时期实际类型的方法

对于多态的理解，也可以看看这个博主写的，通俗易懂。
https://blog.csdn.net/qq_41679818/article/details/90523285

多态存在的三个必要条件：

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

3.1.1、重写

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参
都不能改变。即外壳不变，核心重写！

重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类
能够根据需要实现父类的方法。

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。

class animal {
	public void run() {
		System.out.println("他在跑步");
	}
}
class Dogs extends animal{ 	
	public void run() {
		System.out.println("我在跑步");
	}
}
public class Inherit{
    public static void main(String[] args)
    {
    	animal a = new animal();//animal对象
    	animal b = new Dogs();//Dogs对象
    	a.run();//执行animal类的方法
    	b.run();//执行Dogs类的方法
    }
}

 结果：他在跑步
       我在跑步

重写的规则：

1.参数列表与被重写方法的参数列表必须完全相同。
2.返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类。
3.访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。
4.父类的成员方法只能被它的子类重写。
5.声明为 final 的方法不能被重写。
6.声明为 static 的方法不能被重写，但是能够被再次声明。
7.子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
8.子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
9.重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
10.构造方法不能被重写。
11.如果不能继承一个类，则不能重写该类的方法

3.1.2、重载

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

重载规则:

 1.被重载的方法必须改变参数列表(参数个数或类型不一样)；
 2.被重载的方法可以改变返回类型；
 3.被重载的方法可以改变访问修饰符；
4.被重载的方法可以声明新的或更广的检查异常；
 5.方法能够在同一个类中或者在一个子类中被重载。

class One {
	public void one() {
		System.out.println("123");
	}
	
	public void one(String name) {
		System.out.println("123" + name + "小明");
	}
	
	public void one(String name, int age) {
		System.out.println("123" + name + "小明" + age + "18");
	}
}

 方法名相同，但各自的参数不同。

3.2、向上转型与向下转型

     1. 一个类型的引用在指向不同的对象时会有不同的实现：
         学生 student1 = new 老师();
         学生 student2 = new 校长();
         student1.完成工作();
         student2.完成工作();

2.同一个对象，转型成不同的类型时，会有不同的功能：
     老师 teacher = new 老师();
     学生 student = teacher;
   校长 principal = teacher;
  student.完成作业();
     principal.开会();

向上转型通俗地讲即是将子类对象转为父类对象。此处父类对象可以是接口。

class animal {
	public void eat() {
		System.out.print("123");
		
	}
}
class Dogs extends animal{ 
	public void sleep(){
		System.out.print("456");
	}
}
public class Inherit{
    public static void main(String[] args)
    {
    
		// 向上转型：将父类引用指向子类对象
    	animal a = new Dogs();
    	a.eat();
    	//如果是a.sleep();编译出错，因为sleep()不是父类的方法。
    }
}
//输出：123

向下转型和向上转型相反，如果把一个父类类型强制转换为子类类型，就是向下转型。