1.面向对象理解
JAVA学习的面向对象是相对于面向过程而言的。面向过程强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对 象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
面向对象的三大特征：封装，继承，多态
面向对象的两个重要对象理解：
类：对一类事物的描述，是抽象的、概念上的定义
对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)
>面向对象程序设计的重点是类的设计
>设计类，就是设计类的成员。
面向对象设计原则：
* 1.创建类，设计类的成员
* 2.创建类的对象
* 3.通过“对象.属性”或“对象.方法”调用对象的结构
其中：属性 = 成员变量 = field = 域、字段
方法 = 成员方法 = 函数 = method
创建类的对象 = 类的实例化 = 实例化类
在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构>Scanner,String等 >文件：File >网络资源：URL。涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象，即“万物皆对象”
2.类
面向对象设计的重点就是类的设计，类的设计其实就是类的成员的设计。在现实生活中，不管是人、动物、植物等，都是由最基本的细胞构成。同理在JAVA中代码世界是由不同功能的类组成。常见类的成员有属性和方法。
属性对应于类中的成员变量，方法对应类中成员的方法。
类的语法格式：
修饰符class 类名{
属性声明
方法声明
}
说明：修饰符public：类可以被任意访问，类正文用{ }裹起来。
public class World{
public int ID;
private String City;
public void ShowPeople(String City){
City = "上海";
}
}创建自定义的JAVA类步骤如下：
1.定义类（修饰符 类名）
2.编写类的属性（考虑修饰符 属性类型 属性名 初始化）
3.编写类的方法（修饰符 返回值 方法名 形参）
3.对象的创建和使用
类名 对象名 = new 类名();
使用”对象名.对象成员“的方式类访问对象成员（属性和方法）
public class Animal {
public int legs;
public void eat(){
System.out.println(“Eating.”);
}
public viod move(){
System.out.println(“Move.”);
}
}
public class Zoo{
public static void main(String args[]){
//创建对象
Animal xb=new Animal();
xb.legs=4;//访问属性
System.out.println(xb.legs);
xb.eat();//访问方法
xb.move();//访问方法
}
}匿名对象：不定义对象的句柄，而直接调用这个对象的方法
PhoneMall mall = new PhoneMall();
//匿名对象的使用
mall.show(new Phone());
//其中，
class PhoneMall{
public void show(Phone phone){
phone.sendEmail();
phone.playGame();
}
4.类的成员：属性
语法格式： 修饰符 数据类型 属性名 = 初始化值 ;
说明1: 修饰符
常用的权限修饰符有：private、缺省、protected、public
其他修饰符：static、final (暂不考虑)
说明2：数据类型
任何基本数据类型(如int、Boolean) 或 任何引用数据类型。
说明3：属性名
属于标识符，符合命名规则和规范即可。
public class Person{
private int age; //声明private变量 age
public String name = “Lila”; //声明public变量 name
}
5.类的成员：方法
方法的声明：权限修饰符 返回值类型 方法名(形参列表){
方法体
}
注意：static、final、abstract 来修饰的方法，后面再讲
关于权限修饰符：默认方法的权限修饰符先都使用public
Java规定的4种权限修饰符：private、public、缺省、protected
其中方法被调用一次，就会执行一次，没有具体返回值的情况，返回类型用关键字void表示，那么方法体重可以不必使用return。如果使用，仅用来结束方法。
定义方法时，方法的结果应该返回给调用者，交由调用者处理。
方法中只能调用方法或属性，不可以在方法内部定义方法。
方法的重载：
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
即："两同一不同":同一个类、相同方法名
参数列表不同：参数个数不同，参数类型不同
//如下的4个方法构成了重载
public void getSum(int i,int j){
System.out.println("1");
}
public void getSum(double d1,double d2){
System.out.println("2");
}
public void getSum(String s ,int i){
System.out.println("3");
}
public void getSum(int i,String s){
System.out.println("4");
}递归方法：
一个方法体内调用方法它自身。方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
// 例1：计算1-n之间所自然数的和
public int getSum(int n) {// 3
if (n == 1) {
return 1;
} else {
return n + getSum(n - 1);
}
}
// 例2：计算1-n之间所自然数的乘积:n!
public int getSum1(int n) {
if (n == 1) {
return 1;
} else {
return n * getSum1(n - 1);
}
}
//例3：已知一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),
//其中n是大于0的整数，求f(10)的值。
public int f(int n){
if(n == 0){
return 1;
}else if(n == 1){
return 4;
}else{
// return f(n + 2) - 2 * f(n + 1);
return 2*f(n - 1) + f(n - 2);
}
}
//例4：斐波那契数列
//例5：汉诺塔问题
//例6：快排6.面向对象特征：封装性
Java中通过将数据声明为私有的(private)，再提供公共的（public） 方法:getXxx()和setXxx()实现对该属性的操作，以实现：
隐藏一个类中不需要对外提供的实现细节；
使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑， 限制对属性的不合理操作；
便于修改，增强代码的可维护性；
class Animal {
private int legs;// 将属性legs定义为private，只能被Animal类内部访问
public void setLegs(int i) { // 在这里定义方法 eat() 和 move()
if (i != 0 && i != 2 && i != 4) {
System.out.println("Wrong number of legs!");
return;
}
legs = i;
}
public int getLegs() {
return legs;
}
}
public class Zoo {
public static void main(String args[]) {
Animal xb = new Animal();
xb.setLegs(4); // xb.setLegs(-1000);
//xb.legs = -1000; // 非法
System.out.println(xb.getLegs());
}
}Java规定的四种权限修饰符：private < 缺省 < protected < public
7.构造器
构造器的作用：
* 1.创建对象
* 2.初始化对象的信息
如果没显式的定义类的构造器的话，则系统默认提供一个空参的构造器。定义构造器的格式：权限修饰符 类名(形参列表){}。一个类中定义的多个构造器，彼此构成重载一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器。一个类中，至少会有一个构造器。
//构造器
public Person(){
System.out.println("Person().....");
}
public Person(String n){
name = n;
}
public Person(String n,int a){
name = n;
age = a;
}
8.this关键字
this理解为：当前对象 或 当前正在创建的对象
在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是通常情况下，我们都择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
class Person{ // 定义Person类
private String name ;
private int age ;
public Person(String name,int age){
this.name = name ;
this.age = age ; }
public void getInfo(){
System.out.println("姓名：" + name) ;
this.speak();
}
public void speak(){
System.out.println(“年龄：” + this.age);
}
}9.pacakage、import的使用
为了更好的实现项目中类的管理，提供包的概念。使用package声明类或接口所属的包，声明在源文件的首行。包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”。每"."一次，就代表一层文件目录。
pack1\pack2\PackageTest.java
package pack1.pack2; //指定类PackageTest属于包pack1.pack2
public class PackageTest{
public void display(){
System.out.println("in method display()");
}
}JDK中主要的包：
关键字import：
导入
* 1. 在源文件中显式的使用import结构导入指定包下的类、接口
* 2. 声明在包的声明和类的声明之间
* 3. 如果需要导入多个结构，则并列写出即可
* 4. 可以使用"xxx.*"的方式，表示可以导入xxx包下的所结构
* 5. 如果使用的类或接口是java.lang包下定义的，则可以省略import结构
* 6. 如果使用的类或接口是本包下定义的，则可以省略import结构
* 7. 如果在源文件中，使用了不同包下的同名的类，则必须至少一个类需要以全类名的方式显示。
* 8. 使用"xxx.*"方式表明可以调用xxx包下的所结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入
* 9. import static:导入指定类或接口中的静态结构:属性或方法。
1388
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
