4、Java基础（2）

Java基础

1、面向对象

面向过程：分析解决问题的所需要的步骤，然后我们用函数来一步一步的调用实现。
面向对象：OOP（Object Oriented Programming）面向对象编程，以类的方式组织代码，以对象的方式封装数据。

拓展：

值传递与引用传递：
1.值传递：
	int a=1;
	Demo.change(a);
	System.out.println(a);//1
	
	public static void change(int a){
	a=10;
	}
2.引用传递：对象，本质还是值传递。

2、类

类的概念：我们把某些具有相同的属性和行为的事物抽象成一类。
对象的概念：类是一个概念，对象是一个具体的实例。
定义类的语法：
	class 类名{
		属性
		方法
	}
创建类的时候要注意：
1.类名的和文件名没有任何关系，前提是class类前面不要加pubic，如果加上public代表这个类是主类。
2. 如果在定义类的时候public class Teacher{} 这个类就是主类。一个java文件中只能有一个主类。而且这个文件名字必须要和主类名字一致。

3、创建对象

语法：类名 变量名 = new 类名（）;
通过对象可以访问属性   变量名.属性名字
通过对象可以调用方法	变量名.方法名(..)
定义：使用new关键字创建对象，除了分配内存空间，还会初始化以及对类中构造器进行调用。
类中构造器：构造方法，是在创建对象时必须调用的。
构造器特点：
	1.必须和类的名字相同
	2.必须没有返回类型，也不能写void
构造器语法：
权限修饰符 类名（数据类型 参数名，...）{

	  }
构造器作用：
	1.new 本质在调用构造方法
	2.初始化对象的值
注意：一个类存在有参数的构造器那么默认的构造器就被覆盖，如果想使用默认构造器
需要显示的定义。

4、创建对象内存分析

栈：用于存储基本数据类型的值或者是局部变量。先进后出，存取的容量小，存取的速度快。
堆：用于存储引用数据类型，存取容量大，存取速度慢。
数据共享区：用于存储引用数据类型，存储一些共享的数据（方法）
每一个类class加载到数据共享区中，jvm会解析这个类的内容，方法是每个对象共享, 但是方法内的属性的是哪个对象调用这个方法，那么这个属性就是在那个对象的。
对象存储在堆中，引用存储在栈中，堆中的每一个对象的数据是隔离的。

5、封装

目的：提高数据安全性，通过封装，可以实现对属性的访问权限控制，同时增加了程序的可维护性。（高内聚，低耦合）
简单定义：属性私有，get/set方法

6、继承

描述类的时候，我们如果发现几个类有重复的属性和方法我们就可以采用继承的方式来设计。
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
语法：
使用extends关键字来继承
class 子类	extends 父类{
	子类属性
	子类方法
}
继承特点：java中只能做单继承

7、super关键字

1.子类通过默认构造器实例化的过程中父类的构造器先被调用，然后再调用子类的构造器，在子类构造器内部默认的调用super();
注意：如果父类带有有参数的构造器，并且没有显式的定义父类的默认构造器，默认构造器被覆盖，导致子类的构造器无法通过super()来做调用，就会编译报错，需要显式的定义父类的默认的构造器。
2. 如果子类的构造器中调用了父类中的有参数的构造器，默认super()的调用就不会有了。不能在子类的构造器中调用两个super(…)
3. super(..)的调用必须要放在方法的第一行。
4.super可以表示父类的引用，我们可以使用super和this来区分父类和子类中同名的属性。
重点：
	1.理解super(…)对于父类构造器的调用
	2.super表示子类内部的那个父类的对象的引用
This关键字:
		1.代表当前类的的指定实例的引用
		2.可以区分同名的属性和局部变量
		3.通过this可以调用同类中的构造器（this(),  this(参数列表)）
		4.调用本类里面的属性， this.属性名，this.方法()

8、重写

在子类继承父类时，子类的方法和父类的方法相同（访问修饰限制符， 返回值类型， 方法名， 参数列表），方法体不同。这种子类的方法将父类的方法覆盖叫做重写

重写和重载的区别：
	重写（override）：在父子类的继承中有相同的方法，唯一不同就是方法体，一般是父类的该方法满足不了子类的需求所以才发生重写。
	重载（overload）：重载是在同一个类中，有着相同的方法名但是参数的数据类型或者参数的个数不同这两个方法就是重载。重载的目的：节省类中的命名资源和提高代码的可读性。

9、多态

定义：同一方法可以根据发送对象的不同而采用多种不同的行为方式。
条件：1.有继承关系
	 2.子类重写父类方法
	 3.父类引用指向子类对象
注意：多态是方法多态，属性没有多态性。
父子类之间的转换：
	1.子类转换成父类：
		（1）子类可以自动转型成父类
		（2）如果子类对父类的方法有覆写，并且子类的实例赋值给父类的引用，通过这个引用来调用这个覆写的方法的				时候，调用的是子类。
		（3）父类指向子类的实例的引用不能调用子类的特有的方法和属性。
		（4）如果父子类有同名的属性，那么父类指向子类的实例的引用调用这个属性的时候调用的还是父类的，不要和方法混淆。
	2.父类转换成子类：
		（1）父类转换成子类不能自动完成。
		（2）父类转换成子类的前提是父类的真身是这个子类，转回子类后，就可以访问子类内部的方法和属性。
		（3）如果这个父类的真身是子类B，不能强制转换成子类A，只能转换成B。
		（4）抽象类作为父类同样符合上述理论
		（5）接口中也是完全符合上述理论，但是注意接口中没有属性。

10、static关键字

1.属性上 ：
加上static的属性是类属性，静态属性。
	类属性的特点：
	1.类属性的访问可以通过  类名.类属性， 还可以通过对象来访问。
	2.类属性的当前的class文件加载进入jvm类属性就被初始化, jvm执行完毕Student.class文件出了jvm，类型属		性也就消失了。 
	3.类属性可以被这个类的每一个对象共享
2.方法上：
语法
public static 返回值（void） 方法名（数据类型1 变量1，….）{
	方法体
		[return 结果]
    }
 
static修饰在方法上就是类方法。
类方法的特点：
	1.类方法的访问可以通过  类名.类方法， 还可以通过对象来访问。
	2.类方法的当前的class文件加载进入jvm类方法就被初始化, jvm执行完毕Student.class文件出了jvm，类型方法也就消失了。 
	3.对象方法和类方法都是被对象共享。 类方法初始化很早jvm加载这个类的时候这个方法就初始化了.对象方法也是早早的就进入jvm了，但是不一定被启用了，只有先创建了对象，才有可能使用这个方法。
	4.类方法不能访问对象属性和对象方法（类方法只能访问类属性和类方法）
	5.对象方法内可以访问对象属性，对象方法，类属性，类方法。
3.代码块：
语法：class A{
	//静态代码块
	static{

	}
}
1.静态代码块主要是用于初始化资源。
2.静态代码块在main之前执行。
3.静态代码块可以范围类属性（必须先定义）和类方法

11、final关键字

1.变量上：如果final修饰在变量上，这个变量不能修改。
2.属性上：如果final在属性上，要么直接给初始值， 要么在构造器中给初始化，如果存在多个构造器，每一个构造器里面都要有final这个属性的初始化。
3.方法上：final修饰在方法上不能被覆写。
4.类上：如果一个类被final修饰，就不能被继承。

12、抽象类

当多个具体的实体类存在着共同的行为，但是有不同的表现，我们在父类继承过程中父类的方法具体实现不确定，但是能确定的是他们都有这种行为。
我们要把这种行为方法作为抽象方法。
语法：
abstract class  类名{
	属性
	方法
}
注意：抽象类中可以没有抽象方法，但是有抽象方法的类一定是抽象类
特点：1.抽象类不能被实例化。
	2.抽象类必须被子类继承才能使用子类实例化。
	3.继承了抽象类的非抽象类必须实现抽象类的所有抽象方法。
	4.抽象类也可以继承抽象类，这样不需要实现父抽象类的方法。
	5.抽象类的抽象方法不能和private，final， static共存。

13.接口

定义：当一个抽象类，如果抽象类中的所有方法都是抽象的，那么我们就可以把它定义为一个接口，接口是对行为的抽象。类是对属性和行为的抽象。

语法
interface 接口名{
	方法定的定义；
	….
}
特点：
1.接口中的方法的定义不需要Abstract来修饰，默认就是抽象的
2.接口是不可以实例化的，需要有类来实现接口实现接口的语法：
class 类名	implements 接口名，接口名,…{
		//实现每一个接口中的方法
	}
3.接口中的方法不能和private，static和final共存
4.在接口中可以定义”属性”，可以通过接口的实现类的实例来访问（不推荐），推荐使用接口名.常量，这是一个常量默认是public, static ,final
5.接口可以继承接口(多继承)

14、内部类（了解）

类内部的类就是内部类。
位置：把一个类定义到另一个类中，那么内部的类就是内部类。
注意：内部类不能直接创建
创建内部类的语法：
	外部类.内部类 变量名 = new 外部类对象.new内部类对象
内部类的外部类的方法如果想要访问内部类的方法，必须创建内部类的对象，根据内部类的对象来访问。

15、异常

1.try…catch处理异常：
    1.try内部发生异常下面的代码执行
    2.产生的异常对象被catch块里面的参数接收
    3.catch块来处理异常（如何处理要根据具体的业务要求）
    4.如果异常对象被catch来处理就不会向上抛出
    5.由于异常对象被处理了，异常后面的代码就会正常的执行，调用端不会感知到异常的产生（因为没有向上抛出异常对		象），后面的代码正常执行。
2.try…finally:发生了异常会向上的抛出，但是finally里面的代码永远会得到执行。
3.try…catch…finally:finally里面适合做方法的资源关闭和收尾的工作。
4.throws IOException:编译期的异常建议大家通过try…catch来处理,运行时的异常建议向上抛，最顶层来处理。