java入门笔记（3）

while循环结构

while(condition) {

// body of loop

}

一般在循环体内控制循环的结束条件：让循环条件为false或break

4.2  do while循环结构

do {

// body of loop

} while (condition);

至少执行一次循环。

示例：

分别使用while和do-while循环计算1-100的和

4.3  While和do while的区别

do  while先执行  后判断     所以它至少执行一次

while先判断条件  再执行     有可能一次也不执行

所有的循环，都可能出现死循环

4.4  for循环结构

4.4.1  语法

for(initialization; condition; iteration) {

// body

}

四个部分：初始化部分A、循环条件B、循环体D、迭代部分C

A只执行一次。

执行B判断真假，如果真T，执行D，然后再执行C变量变化

演示案例：

使用for循环计算1-100的和

4.4.2  嵌套的for循环

循环是可以嵌套的，包括while和do-while循环

4.4.3  使用两个变量控制循环

案例：输入两个数，查找两个数的中间数

for(int i=0, j=10; i

//输出i和j的值

}

练习总结：

学生基本语法可以掌握，稍有逻辑不会，建议多做稍有逻辑练习题

例如：

i%2==0  知道是2的整倍数的判断  基本语法没问题

判断一个数字i 能否被2 到（i-1）任意一个整除，就不会了。

4.5  break和continue

break：终止直接包含的循环体，结束（本层）循环

continue：终止本次循环，直接执行循环的下一次

案例：

打印1-20之间的偶数，如果大于10则终止循环（break）

打印1-20之间的偶数，如果等于10则终止本次循环（continue）

数组

5.1  数组的概念

一个具有固定大小，可以容纳相同类型数据的集合.

数组元素的类型：可以是基本类型，也可以是引用类型

数组可以认为是Java中最简单的复合类型。

数组的声明和使用，在语法上与C语言类似，但是在内部实现机制上有本质的区别。

5.2  数组声明

两种方式：强烈建议采用第一种方式

int[]  nums;  或

int  nums[];

5.3  数组创建与初始化

5.3.1  使用new创建数组

int[] nums;        //声明数组，并没有创建数组，没有开辟堆内存。

nums = new int[5];  //创建数组，必须设置长度   开辟堆内存

new：用于分配内存的特殊运算符。通过new分配的数组，其元素会被自动初始化为0(对于数值类型)、false(对于boolean类型)或null(对于引用类型)。

说明：获得一个数据需要两个步骤，第一步是声明，第二步是创建数组对象。

一个数组就是一个对象。数组是动态创建的，所有对象都是动态创建的。

5.3.2  创建数组的三种方式

int[]  nums = new int[5];  //初始化为默认值

int[]  nums = {1,2,3,4,5};  //初始化为{}中指定的值，静态初始化

int[]  nums = new int[] {1,2,3,4,5};//初始化为{}中指定的值，静态初始化

5.3.3  创建数组需要注意的问题

1、创建数组时必须知道数组的长度，否则new不知道要开辟多大的内存

2、第二种方式创建数组，必须在声明数组的同时创建数组

3、创建数组之后，数组的长度不能再改变。

说明：

数组的初始化分为静态初始化和动态初始化，静态初始化在初始化时由程序员显示指定每个数组元素的初始值，由系统决定数组长度。

5.4  数组操作

1、通过下标访问数组元素

为指定的数组元素赋值、使用数组元素。如果数组下标越界，会抛出异常。

2、通过循环处理数组（打印输出所有数组元素）

数组与循环是分不开的

3、可以使用length属性获取数组的长度，从而可以避免数组越界。

示例5.1

创建数组、静态初始化、遍历输出数组元素

示例5.2  随机数生成

使用Math类的random方法，动态初始化

类与对象的概念

类：指的是对客观事物的一种描述，是对现实中一类具有共同属性和行为的事物的抽象。

对象：指的是具体存在的事物，是能够看得到摸的着的真实存在的实体。

举例说明：

我们可以将“汽车”看作一个类，在这个类中定义了汽车的属性和行为，比如颜色、品牌、速度等属性，以及加速、刹车、转弯等行为。

那么，当我们要描述具体一辆汽车时，就需要创建一个该类的对象，并根据需要设置其相应的属性值或对其进行行为操作。

另外，我们可以根据同一个类创建多个不同的对象，每个对象的属性值和行为可能都不同。例如一个品类的汽车肯定不止一台实车。

因此，也可以理解成，类表示的是共性，对象则用来表示具体个性。

6.1.1  面向对象的概念

面向对象编程：OOP（Object-Oriented Programming）

6.1.2  使用类和对象开发程序的基本步骤

对于面向对象编程，主要工作就是编写类。面向对象开发的步骤：

l 开发类，类 = 属性（成员变量） + 方法

l 通过new关键字创建对象

l 使用类中的属性和方法：对象.属性名  对象.方法名()

6.1.3  类与对象

（1）类是一种逻辑结构，对具有公共属性特征和行为（功能）的一个群体进行描述。例如可以定义Student类描述学生的公共属性和行为，定义一个Teacher类，描述老师的公共属性和行为。

（2）定义了类之后，就可以根据类创建(new)出一个实例。比如学生张三，老师王老师。

通俗地说：

类定义了一种新的数据类型。对象就是根据类定义的变量。可以将类看做是复合类型。

类是对象的模板(template)，对象是类的实例(instance)。因为对象是类的实例，所以经常会看到交换使用“对象”和“实例”这两个词。

教学需要注意的问题：

开始时不要讲理论，提示一下后就直接编写类，声明并创建对象。然后结合具体的程序，介绍上面的概念。

6.2  定义类

程序 = 数据  +  算法

类   = 属性  +  方法

6.2.1  类的一般形式

class 类名 {  //类名通常以大写字母开始

类型  变量1;

类型  变量2;

…

类型 方法名(参数列表) {

// 方法体

}

…

}

在类中定义的变量和方法都称为类的成员。所以变量又称为成员变量，方法又称为成员方法。

6.2.2  类的属性

类的成员变量又称为类的属性。

public class Student {

/**

 * 属性 成员变量

 * 类的{}内直接声明(定义)的变量  叫  成员变量/实例变量

 */

String  name;

int  age;

double  score;

}

属性属于类的某个具体对象。类的每个实例(即，类的每个对象)都包含这些变量的副本，因此在类中定义的变量又被称为实例变量。

6.2.2  类的方法

方法是对象行为特征的抽象，类具有的共性的功能操作，称之为方法。方法是个“黑匣子”，完成某个特定的应用程序功能。

方法的基本语法：

修饰符  返回类型  方法名（形参列表）{

//功能代码

}

形参可以为空，可以有多个，形参的类型可以是基本类型也可以是引用类型。

public class Student {

String  name;

int  age;

double  score;

void  study(){

//

}

void  show(){

//

}

}

注意：

方法中定义变量称为局部变量。

如果没有返回值，则方法的返回类型必须为void

当方法有具体的返回类型时，则必须使用return语句返回一种值。

方法深入分析：

对象的声明与创建

Student   stu1;    //声明对象的引用

sut1  =  new Student();  //创建对象

public static void main(String[] args) {

Student stu1 = new Student();

stu1.name = "张三";    //访问对象的属性

stu1.age = 20;

stu1.score=95.5;

stu1.show();           //方法调用

Student stu2 = new Student();

stu2.name = "李四";    //访问对象的属性

stu2.age = 22;

stu2.score=98;

stu2.show();           //方法调用

Student stu3 = stu2;

stu3.show();

}

提示：如何使用对象的成员变量和方法

注意：

属性属于类的具体对象，不同对象的属性值通常是不同的。

虽然方法也是通过对象调用的，但是各对象共享相同的方法。

教学需要注意的问题：

带着学生多定义几个简单的类，让学生自己也多定义几个类。

逐步增加类的复杂程度

6.4  类练习

Teacher类

定义Teacher，属性：姓名，年龄，工资

方法：Teach()； Show();

Box类

属性：长、宽、高

方法：计算体积

Dog类：

属性：name color、age

方法：eat()

Cat类：

属性：name color、age

方法：eat()

Triangle类：底、高、计算面积

Reatangle类：长length、宽width，计算面积area

Circle类：半径，计算面积

测试类：Engineer类

6.5  为引用变量赋值

//Box b1 = new Box(); //创建对象，让b1指向(引用)所创建的对象

Box b2 = b1;

注意：b1和b2引用同一个对象。

对象引用与对象的关系：

（1）对象引用，有时也称为对象引用变量，或称为引用变量。

（2）对象引用与对象在物理上是两个不同的东西。

（3）对于上图，我们通常说b1引用（有时也称为指向）图中的那个Box对象。

（4）对象只能通过对象引用来操作。有时直接使用对象引用代指对象，例如对于上面的例子，有时会直接将b1引用的对象称为“对象b1”或“”b1对象。

（5）将一个对象引用赋值给另一个对象引用，则两个引用变量指向同一个对象。

（6）对引用变量进行相等性比较，例如b1==b2，是比较两个引用变量是否引用同一个对象，所以b1==b2的结果为true。对对象引用进行相等性比较，有时也直接称为对象的相等性比较。

注意：基本变量与引用变量的区别

基本类型的变量位于栈内存中，引用变量所所引用的变量位于堆内存中。

6.6  构造器/构造方法

构造方法的作用：给类（对象）中的属性初始化

实例化：创建对象的实例，开辟对象的数据存储空间

初始化：给对象中的属性进行初始化的赋值

构造方法和普通方法的不同，构造方法不需要声明返回，并且方法名和类名相同

public 类名(){ }

构造方法不需要手动去调用，而是在我们创建对象编写: new 类名() 就是在调用

类的无参构造方法

6.6.1  构造方法的语法

构造方法的作用：开辟内存空间、创建实例、初始化属性值。

构造方法的特点：

（1）方法名与类名相同

（2）不能声明返回类型

（3）不能使用return语句返回值

（4）通常为public

怎么定义构造器

构造方法的名字必须和所在类的名字一致，没有返回值，但不能声明void，访问权限可以为任意，但是一般情况下使用public方法权限，构造方法中的参数可以根据需要自行定义，参数的不同的构造方法构成重载

public 构造方法名(参数){ ... }

/*注意： 1.构造方法没有返回值类型 2.构造方法名必须和该类的类名保持一致，大小写都一样

public Fu(){} //无参的公有构造方法

public Fu(int i){} //参数类型为int的公有构造方法

public Demo(){} //无参的公有构造方法

public Demo(int i){} //参数类型为int的公有构造方法

public Demo(int i,double d){} //参数类型为int和double的公有构造方法

构造器的使用

Java中构造方法的使用有两个地方，一个是跟在关键字new后面，类名加上一个小括号()，小括号内根据实际加上实参，另外一个是跟在关键字super或this后加上一个小括号()，小括号内根据实际添加实参，下面进行举例。

例1:

Demo demo = new Demo(); //这里是调用的是一个无参的构造方法，必须声明在方法中，最好声明在主方法

上面构造方法的参数根据实际添加实参，Jvm根据构造方法的参数不同加载不同的构造方法

public Demo(int a){ this.a=a; //这里调用参数为int类型的本类的构造方法 }

注意：例中this调用构造方法只能出现在构造方法中，而且必须出现在第一行,所以一个构造方法中第一行只能为this或super调用构造方法，两者不能同时调用构造方法出现，而且注意this或super调用构造方法时，要留构造方法出口，意思就是最后调用的构造方法中没有再调用别的构造方法！

注意：

（1）如果没有明确提供构造方法，则系统会提供一个默认的构造方法，默认构造方法（也称为缺省构造方法）没有参数。

（2）如果我们提供了一个构造方法，则系统不再提供无参数的默认构造方法。

（3）如果我们提供了一个有参数的构造方法，同时又需要无参构造方法的话，则必须同时提供一个无参数的构造方法。

7.3  方法深入分析

方法可以看做是独立的功能模块，供调用模块调用，功能模块要有输入、输出，对于方法而言输入就是方法的参数，输出就是方法的返回值。调用者通过参数将需要输入的数据传递给方法，方法通过返回值将输出返回给调用者。

7.3.1  方法定义

1、方法定义包括：访问修饰符、返回类型、方法名、形参、代码块

2、方法必须有返回类型（构造方法除外），可以省略访问修饰符

3、可以有参数，也可以没有参数

7.3.1  方法调用

1、实参与形参的概念

2、方法调用的执行过程

7.3.2  参数传递

方法调用中发生的数据传送是单向的。即只能把实参的值传送给形参，而不能把形参的值反向地传送给实参。因此在函数调用过程中，形参的值发生改变，而实参中的值不会变化。

参数传递：

值传递：Swap(int a, int b)方法

引用传递（对象作为参数，本质上是引用变量作为参数）

7.3.3  return

（1）return语句用于明确地从一个方法返回。即，return语句导致程序的执行控制转移回到方法的调用者。

（2）如果return之后还有代码也不会执行。

（3）如果方法的返回类型为void，可以使用return跳出函数，但是不能使用return返回数据。

（4）可以返回对象。

7.3.4  方法调用

因为封装，不能直接访问其他对象的成员变量，通常是调用其他对象的方法。方法调用有两种情况：

调用相同类中的方法：可以直接调用。（本质上是使用this关键字调用）

调用其他类中的方法：对象.方法名

封装的概念

封装是面向对象的三大特征之一。

面向对象的三大特征是：封装、继承、多态。

类 = 属性 + 方法，类是对属性和方法的封装。类封装了类的成员。

结合Student类，介绍后续内容：

如果在类的外部可以随意访问类的成员，那将属性和方法放到类中就没有意义了。因此Java允许在类中通过访问修饰符控制类成员的访问权限。之前已经接触过public访问修饰符。

7.2  访问控制

在完整学习访问控制之前，先熟悉一下包的概念。

7.2.1  包与访问范围

（1）包的概念

类通常位于某个包中，包(packages)是多个类的容器。它们用于保持类的名称空间相互隔离。因此包是一种名称机制。

例如，Java类库中的类，分别包含在不同的包中：java.lang；java.util。例如String类位于java.langl包中。

（2）定义包

package  pack1

（3）层次化的包

package  com.xszx.sjt2111

（4）包与目录结构

位于包中的类，在文件系统中也必须有与包名层次相同的目录结构。

需要指出的是，包名与文件目录结构一致是针对.class文件而言的，对于源代码文件没有这一要求，但是通常也将源代码文件放到与包名一致的目录结构中。并且建议将源文件与类文件分开存放。

（5）导入包

类的全名为：包名.类名。例如在com.xszx包中定义的Student类，其全面为com.xszx.Student。

当在不同的包中使用某个类时，需要使用类的全名，如果包名很长的话，使用类的全名不是很方便，这时可以通过导入包来避免使用类的全名。

导入包的目的：减少输入

导入包的两种方式

import  java.util.Scanner；

import  java.util.*;

包既是一种命名机制，也是一种可见性控制机制。可以在包中定义该包外部的代码不能访问的类成员。

7.2.2  访问修饰符与访问范围

类是对类成员（属性和方法）的封装，可以通过不同的访问修饰符控制类成员的可见范围，即控制类的成员在多大的范围是可见的。

类成员的访问范围划分为四个：本类、本包、子类、全局（所有包）

为类的成员指定不同的修饰符，就是控制成员的在什么样的范围内是可见的，即在什么样的范围是能够访问的。

	private	默认	protected	public
同一个类中	是	是	是	是
相同包中的其他类	否	是	是	是
子类(不同包、相同包)	否	否	是	是
全局（所有包）	否	否	否	是

访问范围：  本类   <  本包   <  子类  < 全局（所有包）

访问修饰符：private  <  缺省（default） < protected  <  public

封装的通常做法：

（1）将类的属性的访问权限设置为private，提供访问权限为public的set和get方法。在有些情况下不提供set和get方法，有时只提供其中的一个。

（2）提供合理的构造方法，即开发相应参数的构造方法，方便实例化对象。

（3）类的全部或部分方法的访问权限为public，类的公有方法是类对外开放的接口，供外部代码使用类的功能。类的私有方法通常是辅助方法实现部分功能，供类的公有方法调用。

public class TestPersonDemo {
	public static void main(String[] args) {
		/********* begin *********/
		// 声明并实例化一Person对象p
      Person p = new Person();
		// 给p中的属性赋值
   p.setName("张三");
 
   p.setAge(18); 
		// 调用Person类中的talk()方法
p.talk();
		/********* end *********/
 
	}
}
 
// 在这里定义Person类
class Person {
	/********* begin *********/
   private String name;
   private int age;
   public void setName(String name){
       this.name = name;
   }
   public void setAge(int age){
       this.age = age;
   }
   public String getName(){
       return this.name;
   }
   public int getAge(){
       return this.age;
   }
   public void talk(){
 // System.out.println("我是: "+name+", 今年: "+age+"岁");
 System.out.println("我是："+name+"，今年："+age+"岁");
   }
	/********* end *********/
}

封装案例：

在p1包中定义Student类

在p1包中定义StudentTest类，使用Student类，访问该类中的成员变量和方法。

将StudentTest类的定义放入到p2包中，再次访问类中的成员变量和方法。

封装案例：堆栈类

让学生体会封装的原理。

7.4  方法重载

7.4.1  方法重载基础

直接切入主题：

在类中可以定义名称相同的方法：只要形参列表不同即可。

特点：

1、方法名相同

2、形参列表不同：形参的类型/顺序、形参的个数

注意的地方：

1、返回值在区分重载方法时不起作用。修饰符也不起作用

2、当调用重载方法时，Java使用参数的类型和/或数量确定实际调用哪个版本。

方法重载案例：

Calculator类，添加add()方法，计算两个数的和。int  float  double

7.4.2  重载构造方法

Box（double length, double width, double height）

Box（double dim）

Box（Box box）

Box（）

特别说明：

在某个构造方法中可以使用this()调用重载的构造方法：

public  Box（double dim）{

this(dim, dim, dim)

}

class Overloading {
	public int test() {
		System.out.println("test1");
        return 1;
    }
    public void test(int a) {
        System.out.println("test2");
    }   
    //以下两个方法中参数类型的顺序不同
    public String test(int a,String s) {
        System.out.println("test3");
        return "test方法被重载第二次";
    }   
    public String test(String s,int a) {
        System.out.println("test4");
        return "test方法被重载第三次";
    }
}
public class Overload {
	public static void main(String[] args) {
		Overloading a=new Overloading();
        System.out.println(a.test());
        a.test(1);
        System.out.println(a.test(1,"test3"));
        System.out.println(a.test("test4",1));
	}