java学习---新手笔记，多多包涵

引用数据类型{
类，
接口，
数组

}
Java局部变量
局部变量声明在方法、构造方法或者语句块中；
局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
访问修饰符不能用于局部变量；
局部变量只在声明它的方法、构造方法或者语句块中可见；
局部变量是在栈上分配的。
局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
实例变量
实例变量声明在一个类中，但在方法、构造方法和语句块之外；
当一个对象被实例化之后，每个实例变量的值就跟着确定；
实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
实例变量可以声明在使用前或者使用后；
访问修饰符可以修饰实例变量；
实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是 false，引用类型变量的默认值是 null。变量的值可以在声明时指定，也可以在构造方法中指定；
实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。

修饰符
public
protected
private

static
final
abstract
访问控制修饰符
Java 中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持4种不同的访问权限。

默认的，也称为 default，在同一包内可见，不使用任何修饰符。

私有的，以 private 修饰符指定，在同一类内可见。

共有的，以 public 修饰符指定，对所有类可见。

受保护的，以 protected 修饰符指定，对同一包内的类和所有子类可见。

私有访问修饰符-private
私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。
Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据

public class Logger {
   private String format;
   public String getFormat() {
      return this.format;
   }
   public void setFormat(String format) {
      this.format = format;
   }
}

实例中，Logger 类中的 format 变量为私有变量，所以其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量，定义了两个​public​方法：​getFormat() ​（返回format的值）和​setFormat(String)​（设置format的值）
公有访问修饰符-public
被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。

如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。
Java 程序的 main() 方法必须设置成公有的，否则，Java 解释器将不能运行该类。

受保护的访问修饰符-protected
被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问，也能够被不同包中的子类访问。

Protected 访问修饰符不能修饰类和接口，
方法和成员变量能够声明为 protected，但是接口的成员变量和成员方法不能声明为 protected。

class AudioPlayer {
   protected boolean openSpeaker(Speaker sp) {
      // 实现细节
   }
}

class StreamingAudioPlayer {
   boolean openSpeaker(Speaker sp) {
      // 实现细节
   }
}

如果把 openSpeaker() 方法声明为private，那么除了 AudioPlayer 之外的类将不能访问该方法。

如果把 openSpeaker() 声明为 public，那么所有的类都能够访问该方法。

如果我们只想让该方法对其所在类的子类可见，则将该方法声明为 protected。

父类中声明为 public 的方法在子类中也必须为 public。

父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public。不能声明为 private。

父类中声明为 private 的方法，不能够被继承。

抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。

接口
接口必须有子类，使用implements实现接口（一个子类可以实现多个接口），必须实现接口之中的全部抽象方法。
在接口中的所有方法中，都是共有的和抽象的。

Java中，字符串是一个对象。

get 和 post 请求方式的区别:
get 请求方式： 请求数据会以？ 的形式隔开拼接在请求头中， 不安全， 没有请求实 体部分。HTTP 协议虽然没有规定请求数据的大小， 但是浏览器对 URL 的长度是有限制的， 所以 get 请求不能携带大量的数据。
post 请求方式： 请求数据在请求实体中进行发送， 在 URL 中看不到具体的请求数据，安全。 适合数据量大的数据发送。

HTTP响应
响应格式的帧结构
响应行(状态行)： HTTP 版本、 状态码、 状态消息 响应头： 消息报头， 客户端使用的附加信息 空行： 响应头和响应实体之间的， 必须的。 响应实体： 正文， 服务器返回给浏览器的信息

常见的状态码
200 OK //客户端请求成功
400 Bad Request //客户端请求有语法错误， 不能被服务器所理 解
401 Unauthorized //请求未经授权， 这个状态代码必须和 WWW-Authenticate 报头域一起使用
403 Forbidden //服务器收到请求， 但是拒绝提供服务
404 Not Found //请求资源不存在， eg： 输入了错误的 URL
500 Internal Server Error //服务器发生不可预期的错误
503 Server Unavailable //服务器当前不能处理客户端的请求， 一段时间后可能恢复正常。

@Autowired注解是按类型装配依赖对象，默认情况下它要求依赖对象必须存在，如果允许null值，可以设置它required属性为false。@Resource注解和@Autowired一样，也可以标注在字段或属性的setter方法上，但它默认按名称装配。名称可以通过**@Resourc**e的name属性指定，如果没有指定name属性，当注解标注在字段上，即默认取字段的名称作为bean名称寻找依赖对象，当注解标注在属性的setter方法上，即默认取属性名作为bean名称寻找依赖对象。 @Resources按名字，是ＪＤＫ的，@Autowired按类型，是Ｓｐｒｉｎｇ的。

@Override注解是伪代码，用于表示被标注的方法是一个重写方法。

重载：重载的时候，方法名要一样，但是参数类型或个数不一样，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。
重载就是在一个类中，有相同的函名称，但形参不同的函数。
◆方法的重载的规则：·方法名称必须相同。
◆参数列表必须不同（要么个数不同、或者类型不同、参数排列顺序不同等）。
◆方法的返回类型可以相同也可以不相同。
◆仅仅返回类型不同不足以成为方法的重载。

覆写（重写）：需要有继承关系，子类重写父类的方法，方法体不同
1.方法名必须相同
2.参数列表必须相同
3.修饰符（private<protexted<public）：范围可以扩大，但不能缩小
4.抛出异常：范围可以缩小，但不能扩大
若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。
为什么需要重写？？
答：父类的功能子类不一定需要或不一定满足
ALT+INSERT
JAVA是值传递

数组是相同数据类型（数据类型可以为任意类型）的有序集合
◆数组也是对象。数组元素相当于对象的成员变量
◆数组长度的确定的，不可变的。如果越界，则报：ArraylndexOutofBounds

封装：属性私有，get/set

继承 java只有单继承，没有多继承（一个儿子只能有一个爸爸，但是一个爸爸可以有多个儿子s）
extends 子类是父类的扩展
继承是类和类之间的关系，除此之外，类和类之间的关系还有依赖、组合、聚合

super注意点：
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中！|
3.super和this不能同时调用构造方法。
this：
代表的对象不同：
this：本身调用者这个对象
super：代表父类对象的应用
前提
this：没有继承也可以使用
super：只能在继承条件才可以使用
this()本类构造
super()父类构造

多态
多态是方法的多态，属性没有多态
父类和子类有联系
多态存在的三个必要条件
1.继承
2.重写
3.父类引用 指向子类的对象(向上转型)
把子类转换为父类，向上转型
把父类转换为子类，向下转型，强制转换
存在条件：继承关系，方法需要重写，父类引用 指向子类对象，
不能重写的：{
1.static 方法: 属于类，不属于实例
2.final 常量
3.private方法：
不能重写，就没有多态
}

只有在运行的时候才会知道引用变量所指向的具体实例对象。
可扩展性
Person person = new Student03();
//对象可以执行哪些方法，主要看对象左边的类型（左边哪个类型，执行哪个），和右边关系不大
person.run(); //子类重写了父类的方法，执行子类
//子类重写了父类的方法，执行子类
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
对于多态我们可以总结如下：
指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性，而对于子类中存在而父类中不存在的方法，该引用是不能使用的，尽管是重载该方法。若子类重写了父类中的某些方法，在调用该些方法的时候，必定是使用子类中定义的这些方法（动态连接、动态调用）。
多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

抽象类就是来实现封装，多态增强代码的可扩展性

接口
可以多继承
接口只有规范，自己无法写方法
接口中所有定义的方法都是抽象的public abstract
接口都需要实现类
实现了接口的类，就需要重写接口中的方法
java是单继承的，但是可以利用接口实现多继承 一个类可以实现多个接口
面向接口编程
接口不能被实例化，接口中没有构造方法

抽象类与接口

一、抽象类
面向对象的领域一切都是对象，同时所有的对象都是通过类来描述的，
但是并不是所有的类都是来描述对象的。

如果一个类没有足够的信息来描述一个具体的对象，而需要其他具体的类来支撑它，那么这样的类我们称它为抽象类。

比如 new Animal()，我们都知道这个是产生一个动物 Animal 对象，但是这个 Animal 具体长成什么样子我们并不知道，它没有一个具体动物的概念，所以他就是一个抽象类。

需要一个具体的动物，如狗、猫来对它进行特定的描述，我们才知道它长成啥样。
要注意几点：

1、抽象类不能被实例化，实例化的工作应该交由它的子类来完成，它只需要有一个引用即可。
2、抽象方法必须由子类来进行重写。

3、只要包含一个抽象方法的抽象类，该方法必须要定义成抽象类，不管是否还包含有其他方法。

4、抽象类中可以包含具体的方法，当然也可以不包含抽象方法。

5、子类中的抽象方法不能与父类的抽象方法同名。

6、abstract 不能与 final 并列修饰同一个类。

7、abstract 不能与 private、static、final 或 native 并列修饰同一个方法。、

实例一：
定义一个抽象动物类 Animal，提供抽象方法叫 cry()，猫、狗都是动物类的子类，由于 cry() 为抽象方法，所以 Cat、Dog 必须要实现 cry() 方法。如下：

public abstract class Animal(){
public abstract void cry();
}
public class Cat extends Animal{
@Override
public void cry(){
System.out.println(“猫叫：喵喵…”);
}
}
public class Dog extends Animal{
@Override
public void cry(){
System.out.println(“狗叫:汪汪…”);
}
}
public class Test {

    public static void main(String[] args) {
    	Animal a1 = new Cat();
    	Animal a2 = new Dog();
		a1.cry();
        a2.cry();
    }

二、接口
接口是一种比抽象类更加抽象的“类”。
接口本身就不是类，从我们不能实例化一个接口就可以看出。
如new Runnable();肯定是错误的，我们只能new它的实现类。
它所提供的只是一种形式，而没有具体的实现。
同时实现该接口的实现类必须要实现该接口的所有方法，通过使用 implements 关键字

接口是抽象类的延伸，java 了保证数据安全是不能多重继承的，也就是说继承只能存在一个父类，但是接口不同，一个类可以同时实现多个接口，不管这些接口之间有没有关系，所以接口弥补了抽象类不能多重继承的缺陷，但是推荐继承和接口共同使用，因为这样既可以保证数据安全性又可以实现多重继承。

注意问题：
1.1个 Interface 的所有方法访问权限自动被声明为 public。确切的说只能为 public，
2.接口中不存在实现的方法。
3.实现接口的非抽象类必须要实现该接口的所有方法。抽象类可以不用实现。
4.在实现多接口的时候一定要避免方法名的重复。

三、抽象类与接口的区别

使用抽象类来实现:
public abstract class Demo {
abstract void method1();

    void method2(){
        //实现
    }
}

使用接口来实现
interface Demo {
void method1();
void method2();
}
在某种程度上来说，接口是抽象类的特殊化。
对子类而言，它只能继承一个抽象类（这是 java 为了数据安全而考虑的），但是却可以实现多个接口。

一般来说他们存在如下三个不同点：
1、 抽象层次不同。抽象类是对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。

2、 跨域不同。抽象类所跨域的是具有相似特点的类，而接口却可以跨域不同的类。

抽象类是从子类中发现公共部分，然后泛化成抽象类，子类继承该父类即可，但是接口不同，实现它的子类可以不存在任何关系，共同之处。

例如猫、狗可以抽象成一个动物类抽象类，具备叫的方法。
鸟、飞机可以实现飞 Fly 接口，具备飞的行为，
抽象类所体现的是一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在"is-a"关系，即父类和派生类在概念本质上应该是相同的。
对于接口则不然，并不要求接口的实现者和接口定义在概念本质上是一致的， 仅仅是实现了接口定义的契约而已。
3、 设计层次不同。对于抽象类而言，它是自下而上来设计的，我们要先知道子类才能抽象出父类，而接口则不同，它根本就不需要知道子类的存在，只需要定义一个规则即可

所以说抽象类是自底向上抽象而来的，接口是自顶向下设计出来的。

例子：
Door 的抽象概念，它具备两个行为 open() 和 close()，此时我们可以定义通过抽象类和接口来定义这个抽象概念：

abstract class Door{
    abstract void open();
    abstract void close()；
    abstract void alarm();
}
interface Alarm{
    void alarm();
}

class AlarmDoor extends Door implenmts Alarm{
	void open(){}
    void close(){}
    void alarm(){}

}

这种实现方式基本上能够明确的反映出我们对于问题领域的理解，正确的揭示我们的设计意图。

ISP（Interface Segregation Principle）`：面向对象的一个核心原则。它表明使用多个专门的接口比使用单一的总接口要好。

四、总结
1、抽象类在 Java 语言中所表示的是一种继承关系，一个子类只能存在一个父类，但是可以存在多个接口。

2、在抽象类中可以拥有自己的成员变量和非抽象类方法，但是接口中只能存在静态的不可变的成员数据（不过一般都不在接口中定义成员数据），而且它的所有方法都是抽象的。

3、抽象类和接口所反映的设计理念是不同的，抽象类所代表的是“is-a”的关系，而接口所代表的是“like-a”的关系。

Static关键字
在 Java 中 static 表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，当然也可以修饰代码块。

Java 把内存分为栈内存和堆内存，其中栈内存用来存放一些基本类型的变量、数组和对象的引用，堆内存主要存放一些对象。
static 可以用于修饰成员变量和成员方法，我们将其称之为静态变量和静态方法，直接通过类名来进行访问。

static 变量
static 修饰的变量我们称之为静态变量，没有用 static 修饰的变量称之为实例变量。
静态变量是随着类加载时被完成初始化的，它在内存中仅有一个，且 JVM 也只会为它分配一次内存，同时类所有的实例都共享静态变量，可以直接通过类名来访问它。

但是实例变量则不同，它是伴随着实例的，每创建一个实例就会产生一个实例变量，它与该实例同生共死。

static 方法
static 修饰的方法我们称之为静态方法，我们通过类名对其进行直接调用。由于他在类加载的时候就存在了，它不依赖于任何实例，所以 static 方法必须实现，也就是说他不能是抽象方法 abstract。

多重继承
多重继承指的是一个类可以同时从多于一个的父类那里继承行为和特征
Java 是非常和善和理解我们的,它提供了两种方式让我们曲折来实现多重继承：接口和内部类。
一、 接口
对于接口而已，有时候它所表现的不仅仅只是一个更纯粹的抽象类，接口是没有任何具体实现的

抽象 编程思想 持续学习中。。。

抽象 编程思想 持续学习中。。。