java中 提取tag内容 java特征提取

Java是一门面向对象的语言，不同于C语言的面向过程的是，Java中编写代码都是基于对象的。但是写了这么多代码，还是不能完整的表达出Java面向对象四大特征的一些特性，实践是基于理论的 ，于是总结一下：

抽象

　　抽象就是说把一些具有相同特征的对象的共同特征抽取出来，构成一个类，类的属性便是这些对象共有的特征。抽象只关注对象的哪些属性和行为,并不关注这此行为的细节是什么。

封装

　　封装就是将类中属性即成员变量以及操作成员变量的方法绑定起来，对数据的访问只能通过已定义的接口。可以说，封装就是隐藏一切可以隐藏的东西，只向外界提供最简单的接口，封装给对象提供了隐藏内部特性和行为的能力，对象提供一些能这被其它对象访问的方法来改变它内部的数据。

　　1.提供构造方法(有了构造方法才能通过new去构建一个对象 1.构造方法必须和类名称一样2.构造方法不能有返回值)，如果没有设置构造方法，会默认生成一个无参构造方法。

1 private Integer id;
 2     private String name;
 3     private Integer age;
 4     private String gender;
 5 
 6     public Person() {
 7     }
 8 
 9     public Person(Integer id, String name, Integer age, String gender) {
10         this.id = id;
11         this.name = name;
12         this.age = age;
13         this.gender = gender;
14     }

　　构造方法也可以进行重载，这也是类中多态的表现，也叫编译时多态，下面将会讲解多态

1 public Person(Integer id, String name, Integer age, String gender) {
 2         this.id = id;
 3         this.name = name;
 4         this.age = age;
 5         this.gender = gender;
 6     }
 7 
 8     public Person(Integer id, Integer age, String gender) {
 9         this.id = id;
10         this.age = age;
11         this.gender = gender;
12         this.name = "andy";
13     }

　　2.静态代码块(做的类的初始化的工作,执行在new之前)

　　说到静态代码块，就得说一下类的加载过程，类加载总共经过这几个步骤：加载（将.class文件加载到jvm虚拟机)->验证(验证代码的格式，变量的类型，方法的返回值等等是否正确)->准备(这一步也就是将方法区的静态变量，静态代码块中的内容，常量啊等等赋予初始值，如Integer就为0，引用类型就为null等等)->解析(解析就是将代码中的符号引用变为直接引用，符号引用是以字面量的实形式明确定义在常量池中，直接引用是指向目标的指针，或者相对偏移量)->初始化->使用->销毁

1 static {
2         System.out.println("注册");
3 
4         System.out.println("报到");
5 
6     }

　　3. 控制访问，权限关键字

 

 

 　　如成员变量被private修饰，则只在当前类可以访问，于是便实现了屏蔽了外部来直接访问类内部的数据，而是通过类的内部接口即setter和getter来访问其成员变量和修改成员变量，但修饰的只是当前对象的，并没有改变类中的数据。

　　

1  public Integer getId() {
 2         return id;
 3     }
 4 
 5     public void setId(Integer id) {
 6         this.id = id;
 7     }
 8 
 9     public String getName() {
10         return name;
11     }
12 
13     public void setName(String name) {
14         this.name = name;
15     }
16 
17     public Integer getAge() {
18         return age;
19     }
20 
21     public void setAge(Integer age) {
22         this.age = age;
23     }
24 
25     public String getGender() {
26         return gender;
27     }
28 
29     public void setGender(String gender) {
30         this.gender = gender;
31     }

继承（关键字：extends）

　　目的：对父类和方法的复用，也可以说是对父类的扩展。

　　继承是从已有类得到继承信息创建新类的过程,继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段。子类继承父类属性(静态特征)和方法(动态特征)，继承必须遵循封装当中的控制访问。

　　Peson类中定义的通用方法

1 public void eat(){
2         System.out.println("吃东西");
3     }

　　子类Student继承Person，定义了自己的成员变量，定义了自己特有的方法，当然也可以对父类方法进行重写，这是多态中的内容。

1 public class Student extends Person {
 2 
 3     private String classId;
 4 
 5     public Student() {
 6     }
 7 
 8     public Student(Integer id, Integer age, String gender,String classId) {
 9         super(id, age, gender);
10         this.classId = classId;
11     }
12 
13     public void shangke(){
14         System.out.println("去上课");
15     }
16 }

1 Student student = new Student(1,21,"boy","3年2班");
2         System.out.println(student);
3         student.eat();
4         student.shangke();

运行结果：

从上边的代码中可看出，子类中不要再定义属性和行为，直接继承父类，便有了父类的属性和行为，注意：访问修饰符决定了是否可继承

• 多态

　　多态性是指允许相同或不同子类型的对象对同一消息作出不同响应，多态两个重要特征就是向上转型和动态绑定。

　　1、 重载:同一个动作作用在同一个对象上拥有不同的解释 ，在同一个类中，方法的参数列表不同，用关键字注解@overload

　　如Person类重载的构造方法：

public Person(Integer id, String name, Integer age, String gender) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public Person(Integer id, Integer age, String gender) {
        this.id = id;
        this.age = age;
        this.gender = gender;
        this.name = "andy";
    }

 

重载又称静态多态，编译时多态

　　2、 重写:

　　父类引用指向子类对象，在编译时，student就是Person对象，只能调用Person类中的方法，但在运行时，进行动态绑定，调用的却是子类重写父类中调用的那个方法。

1 Person person = new Student(1,21,"boy","3年2班");
2         person.eat();

public void eat(){
        System.out.println("吃东西");
    }
}

 

@Override
    public void eat() {
        System.out.println("吃饭");
    }

 

同一个动作作用在不同的对象上拥有不同的解释 ，在子类与父类中，子类重写父类的方法，用关键字注解@override

重写又称动态多态，运行时多态