Java Note.

什么是面向对象

面向对象是一种符合人类思维习惯的编程思想。在现实生活中，存在着各种不同形态的事物，这些事物之间存在着各种各样的联系。在程序中使用对象来映射现实中的事物，适用对象的关系来描述事物之间的联系，这种思想就是面向对象。（万事万物皆对象）

类和对象

在面向对象的概念中，将具有相同属性及相同行为的一组对象称为类（class），类是用于组合各个对象所共有操作和属性的一种机制，类的具体化就是对象，即对象就是类的是类的实例化。

类的声明格式如下：

[标识符] class 类名

{

       类的成员变量

       类的方法

}

public class Dog {
    String bread;
    int age;
    String color;
    void barking(){
        
    }
    void hungry(){
        
    }
    void sleeping(){
        
    }
}

类的方法

在java中，方法定义在类中，它和类的成员属性一起构成一个完整的类。一个方法有4个要素，分别是方法名、返回值类型、参数列表和方法体。

格式：

修饰符  返回值类型 方法名（参数列表）

{

方法体

return 返回值；

}

构造方法：

Java允许对象在创建时进行初始化，初始化是通过构造方法完成的。

特点：

1.构造方法的名称必须与类的名称完全相同；2.构造方法不返回任何数据，也不需要使用vid关键字声明；3.构造方法的作用是创建对象并初始化成员变量；4.在创建对象时，系统会自动调用类的构造方法；5.构造方法一般用public关键字声明；6.每个类至少有一个构造方法，如果不定义构造方法，java将提供一个默认的不带参数且方法体为空的构造方法；7.构造方法可以重载。

class Person1{
    String name;
    int age;
//无参构造方法
    public Person1(){
      name = "张三";
      age = 20;
    }

    public Person1(String name, int age ){
        //定义构造方法，有两个参数
        this.name = name;
        this.age = age;
    }

    void speak(){
        System.out.println("我叫"+name+",今年"+age+"岁。");
    }

}

public class Text {

    public static void main(String[] args) {

      Person1  p1 = new Person1();
        p1.speak();

    }
}

对象

在java中，使用关键字new来创建一个新的对象，创建对象需要以下三个步骤：

1.声明，声明一个对象，包括对象名称和对象类型

例如：

Person p1;

2.实例化，使用关键字new来创建一个对象

p1 =new Person;

3.初始化，使用new创建对象时，会调用构造方法初始化对象

Person p1 = new Person();

由类产生对象的格式如下： 类名  对象名 = new  类名（）;

访问对象的成员变量或者方法格式如下：

对象名.属性名

对象名.方法名（）

例：

p1.name;
p1.age;
p1.speak();

创建对象应用实例：

class Person1{
    String name;
    int age;
    void speak(){
        System.out.println("我叫" + name + ",今年" + age + "岁。");
    }

}

public class Text {

    public static void main(String[] args) {
        Person1 p1 = new Person1();
        p1.name = "张三";
        p1.age = 20;
        p1.speak();
    }
}

类和对象的关系：

类和对象是面向对象方法的核心概念，类是对某一类事物的描述，是抽象的、概念上的定义，对象是实际存在的该类食物的个体，例如，可以定义一个桌子类，通过这个桌子类，可以定义多个桌子，还可以把桌子类看成是一个模板或者图纸，按照这个图纸，按照这个图纸就可以生产出许多桌子。

对象和对象之间可以不同，改变其中一个对象的某些属性，不会影响到其他的对象，例如按照桌子的图纸，可以生产出相同的桌子，也可以生产出不同高度的桌子。

对象值的传递：

面向对象有三个特征

1. 封装性

封装性是面向对象的核心思想，将对象的属性和方法封装起来，不需要让外界知道具体是现代细节，这就是封装的思想。

（1）属性的封装

 java中类的属性的访问权限的默认值不是private，要想隐藏该属性或方法，就可以加private（私有）修饰符来限制只能在类的内部进行访问。对于类中的私有属性，要对其给出一对方法（getXxx()和setXxx()）访问私有属性，保证对私有属性的操作的安全性。

（2）方法的封装

方法公开的是方法的声明，即只要知道参数和返回值就可以调用该方法，完全的封装是类的属性全部私有化，并且提供一堆方法来访问属性。

例题

class Persons{
    private String name;//姓名
    private int age;//年龄
    private float weight;//体重

   //方法

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

    public float getWeight() {
        return weight;
    }

    public void setWeight(float weight) {
        this.weight = weight;
    }
}
public class Person{
       //属性
    public static void main(String[] args) {
        Persons p1=new Persons();
        p1.setName("张三");
        p1.setAge(20);
        p1.setWeight(80);

        System.out.println(p1.getName());
        System.out.println(p1.getAge());
        System.out.println(p1.getWeight());
    }
}

       2.继承性

继承主要指的是类与类之间的关系，java中继承要使用extends关键字，java中只允许单继承，即一个类只能有一个父类。子类继承父类的特征和行为，使得子类具有父类的各种Attriibutes和method。在继承关系中，父类更通用，子类更具体。父类具有更一般的特征和行为，而子类除了具有父类的特征和行为，还具有一些自己的特殊的特征和行为。

具体格式：

class 子类名extends父类名

 class Animal {
    //属性
    public String name;
    private int id;
    //方法
    public void eat() {
        System.out.println(name + "正在吃");
    }

    public void sleep() {
        System.out.println(name + "正在睡");
    }
}
    //子类Cat继承Animal
    class Cat extends Animal{
    //定义一个方法
    public void shout(){
    System.out.println(name+"正在叫");
        }
  }

注明：1.子类能够继承父类的public和protected成员变量，不能够继承父类的private成员方法。                 2.对于子类可以继承父类成员方法，如果在子类中出现了同名的成员方法，则称为覆盖，即子类的成员方法会覆盖父类的同名成员方法。如果要在子类中访问父类中的同名成员方法，需要使用super关键字来进行引用。

           3.子类可以继承父类成员变量，如果在子类中出现了同名的成员变量，则会发生隐藏现象，即子类的成员变量会屏蔽父类的同名成员变量。如果要在子类中访问父类中的同名成员变量，需要使用super关键字来进行引用。

构造方法：

子类不能够继承父类的构造方法，如果父类的构造方法都是带有参数的，则必须在子类的构造方法中显式地通过super关键字调用父类的构造方法并配以适当的参数列表。如果父类有无参构造方法，则在子类的构造方法中调用父类构造方法则不是必须使用super关键字，如果没有使用super关键字，系统会自动调用父类的无参构造方法。

继承构造方法，例：

class Shape {
    protected String name;
    //父类的无参构造方法
    public Shape(){
        name="shape";
    }
    public Shape (String name){
        this.name=name;
    }
}
class Circle extends Shape{
    private double radius;
    public Circle(){
        radius=0;
    }
    public Circle (double radius){
        this.radius=radius;
    }
    public Circle (double radius,String name){
        this.radius=radius;
        this.name=name;
    }
}

把父类的无参构造方法去掉，则代码会报错，由于父类没有无参构造方法，所以子类的构造方法必须先使用super方法调用父类的有参方法。

  class Shapes {
    protected String name;
    //父类的无参构造方法
 /*
   public Shape(){
        name = "shape";
}
 */

    public Shapes (String name){
        this.name = name;
    }
}
  class Circle extends Shapes{
    private double radius;
    public Circle(){
        super("Circle");
        radius = 0;
    }
    public Circle (double radius){
        super("Circle");
        this.radius = radius;
    }
    public Circle (double radius,String name){
        super(name);
        this.radius = radius;
        this.name = name;
    }
}
public  class Shape{
    public static void main(String[]args){
       Circle s1=new Circle();
       s1.name= s1.name;
        System.out.println(s1.name);

    }
}

重载：

在java中，同一类中的多个方法可以有相同的名字，只要它们的参数列表不同即可，这被称为方法重载。重载是面向对象的一个基本特征。

方法重载注意事项：

1.方法名称必须相同；2.方法的参数列表（参数类型、参数个数、参数顺序）至少有一项不同，仅仅参数变量名称不同是不可以的；3.方法的返回值类型和修饰符不做要求，可以相同，也可以不同。

//方法重载
public class Test1 {
    //一个普通的方法，不带参数
    void test(){
        System.out.println("没有参数");
    }
    //重载上面的方法，并且带了一个整型参数
    void test(int a){
        System.out.println("a:"+a);
    }
    //重载上面的方法，并且代理两个参数
    void test(int a,int b){
        System.out.println("a and b:"+ a + "" + b);
    }
    //重载上面的方法，并且带了一个双静度参数
    double test(double a){
        System.out.println("double a:" + a);
        return a * a;
    }

    public static void main(String[] args) {
        Test1 t1 =new Test1();
        t1.test();
        t1.test(1);
        t1.test(2,3);
        t1.test(2,0);
    }
}

 3.多态性

多态是面向对象程序设计中实现代码重用的一种机制。前面讲过的重载，即调用一系列具有相同名称的方法，这些方法可根据传入参数的不同而得到不同的处理结果，这其实就是多态性的一种体现，属于静态多态。这种多态是在代码编译阶段就确定下来的。还有一种多态形式，在程序运行阶段才能体现出来，称为动态多态。

在实际编写程序时，动态多态的用法更为广泛和有效。动态多态简称多态。还有两个重要概念：

向上转型：父类对象通过子类对象实例化。

向下转型：父类对象可以转换为子类对象但必须强制转换。

多态存在有3个前提：

1.要有继承关系

2.子类要重写父类的方法

3.父类引用指向子类

例：

//多态
//父类Animal

class Animal1 {
    int age = 10;

    public void eat() {
        System.out.println("动物在吃食物");
    }
    public static void run() {
        System.out.println("动物在奔跑");
    }
    public  void shout() {
        System.out.println("动物在叫");
    }
}

//子类Cat继承父类Animal
//子类独有的属性name

class Cat extends Animal1{
    String name="红糖";

    
    public  void eat() {
        System.out.println("猫在吃食物");
    }
    public static void run () {
        System.out.println("猫在奔跑");
    }
    //子类独有的方法lick()

    public void lick () {
        System.out.println("猫在添");
    }
}
public class Animal{
    public static void main(String[] args) {
        //父类通过子类实例化，多态的表现，向上转型
        Animal1 a1 = new Cat();
        //向下转型 必须强制类型转换
        Cat c1 = (Cat) a1;
        c1.lick();
        System.out.println(c1.name);

    }
}

Spring Study

什么是Spring

Spring是一个以IoC和AOP为内核的框架。IoC是Spring的基础。IoC实现的是一种控制，就是以前调new构造方法来创建对象，现在变成了使用Spring来创建对象。DI与IoC的含义相同，从两个角度描述同一个概念，简单的来说，DI就是对象的属性，已经被注入好相关值，直接使用即可。

libs目录中的JAR包分为3类：

1.以RELEASE.jar结尾的是Spring框架class文件的压缩包。

2.以RELEASE-javadoc.jar结尾的是Spring框架API文档的压缩包。

3.以RELEASE-sources.jar结尾的是Spring框架源文件的压缩包。

什么是XML？

它是一种类似于HTML的标记语言，称为可扩展标记语言。所谓可扩展，指的是用户可以按照XML规则自定义标记。

在XML文档中，通过元素的嵌套关系可以很准确地描述具有树状层次结构的复杂信息。

XML语法

在一个完整的XML文档中，必须包含一个XML文档的声明，并且该声明必须位于文档的第1行。这个声明表示该文档是一个XML文档，以及遵循哪个XML版本的规范。

XML文档声明的语法格式如下所示。<?xml版本信息[编码信息][文档独立性信息]?>

从上面的语法格式中可以看出，文档声明以符号“<?”开头，以符号“?>”结束，中间可以声明版本信息、编码信息以及文档独立性信息。需要注意的是，在“<”和“?”之间、“?”和“>”之间以及第一个“?”和 xml 之间不能有空格；另外，中括号([])括起来的部分是可选的。

接下来，针对语法格式中的版本信息、编码信息、文档独立性信息编写一段示例代码，具体如下所示。<?xml version="1.0" encoding="UTF-8"standalone="yes"?>

HTTP协议

HTTP即超文本传输协议，它是一种请求/响应式的协议，客户端在与服务器端建立连接后，就可以向服务器端发送请求，这种请求被称作HTTP请求，服务器端接收到请求后会做出响应，称为HTTP响应，客户端与服务器在HTTP下的交互过程。