封装:
概念：封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问，适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。
原则：将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。主要运用就是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 }
面向对象编程的这三大特性，自己肯定总结的不够全面，主要能给我一点印象，如果有错的地方欢迎大家来纠错