Java中的三大特性：封装、继承、多态

封装:

概念：封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问，适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

原则：将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。主要运用就是JavaBean

代码：创建JavaBean

 1 //创建一个Person类
 2 public class Person  {
 3     private String name;  //private私有方法修饰变量，把变量封装起来
 4     private int age;
 5 //无参构造方法
 6     public Person() {
 7     }
 8 //有参构造方法
 9     public Person(String name, int age) {
10         this.name = name;
11         this.age = age;
12     }
13 //set、get方法
14     public String getName() {
15         return name;
16     }
17
18     public void setName(String name) {
19         this.name = name;
20     }
21
22     public int getAge() {
23         return age;
24     }
25
26     public void setAge(int age) {
27         this.age = age;
28     }
29 //重写toString方法：便于输出格式好看点
30     @Override
31     public String toString() {
32         return "Person{" +
33                 "name='" + name + '\'' +
34                 ", age=" + age +
35                 '}';
36     }
37 }

赋值就通过构造方法就可以了

访问控制修饰符范围：

修饰符/类	本类	同一个包中的类	子类	其他类
public	可以	可以	可以	可以
protect	可以	可以	可以	不可以
无访问修饰符	可以	可以	不可以	不可以
private	可以	不可以	不可以	不可以

继承：

概念：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接  访问父类中的非私有的属性和行为。

好处：提高代码的复用性。类与类之间产生了关系，是多态的前提。

代码：

 1 //定义父类
 2 public class Fu {
 3     int age =1;
 4     public void show(){
 5         System.out.println("父类的方法");
 6     }
 7     public Fu() {
 8         System.out.println("父类无参构造");
 9     }
10     public Fu(String name){
11         System.out.println(name);//父类有参构造要在子类构造方法中通过super关键字赋值
12     }
13 }
14
15 //定义子类继承父类
16 public class Zi extends Fu {
17     int age =2;//定义和父类相同的成员变量
18     public Zi() {
19     super("给父类有参构造赋值成功");//通过super关键字给父类有参构造赋值
20     }
21     public  void show(){//成员方法重名：重写
22       //  super.show();//super关键字调用父类同名方法
23        System.out.println("子类的方法");
24     }
25     public void show1(){
26         System.out.println(this.age);//this关键字调用本类的成员方法
27         System.out.println(super.age);//super关键字调用父类的成员方法
28     }
29 }
30
31 //测试类
32 //父类构造方法有参数必须要子类的构造方法通过super关键字赋值，不然要报错
33 public class ExtendsTest {
34     public static void main(String[] args) {
35       Zi zi = new Zi();
36        zi.show();
37        zi.show1();
38     }
39 }

输出结果：

多态：

概念：多态是指同一行为，具有多个不同表现形式。

前提：

1. 继承或者实现【二选一】

2. 方法的重写【意义体现：不重写，无意义】

3. 父类引用指向子类对象【格式体现】

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。

代码：

 1 //父类
 2 public abstract class Animal {
 3     public abstract void eat();
 4 }
 5
 6 //子类Dog继承
 7 public class Dog extends Animal {
 8     @Override
 9     public void eat() {//重写父类的方法
10         System.out.println("狗吃东西");
11     }
12 }
13
14 //子类Cat继承
15 public class Cat extends Animal {
16     @Override
17     public void eat() {//子类重写
18         System.out.println("猫吃东西");
19     }
20     public void run(){//子类自己定义的方法
21         System.out.println("猫跑开了");
22     }
23 }
24
25
26 //测试类
27 public class Test {
28     public static void main(String[] args) {
29         Cat cat = new Cat();
30         Dog dog = new Dog();
31 //        多态规定，执行的是子类重写的方法，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用 showAnimalEat都可以完成。
32         showAnimaleat(cat);
33         showAnimaleat(dog);
34
35 /*//        向上转型
36         Animal c =new Cat();
37 //        向下转型
38         Cat cat = (Cat) c;
39         cat.run();*/
40 //      instanceof关键字运用
41         Animal an =new Cat();
42         if (an instanceof Cat){
43             Cat cat1 = (Cat) an;
44             cat1.eat();
45         }else {
46             Dog dog1 = (Dog) an;
47             dog1.eat();
48         }
49     }
50     public static void showCateat(Cat cat){
51         cat.eat();
52         cat.run();
53     }
54     public static void showDogeat(Dog dog){
55         dog.eat();
56     }
57     public static void showAnimaleat(Animal animal){
58         animal.eat();
59     }
60 }

面向对象编程的这三大特性，自己肯定总结的不够全面，主要能给我一点印象，如果有错的地方欢迎大家来纠错