Java程序设计笔记

public static void main(String[] args){

System.out.println("hello world!");

//1.int 整形

int a=5;

//2.short

short b=3;

//3.long 在赋值的时候在后面需要用大写的L

long l=55556565656L;

//4.float

float f=(float)55.3;

float f1=55.3F;

//5.double

double d=55.67;

char ch='a';

//7.byte 字节

byte b1=55;

//8.boolean 布尔;

boolean ="false";

}

取值范围：

正在上传…重新上传取消

注意：字符串（string）不是8大基本数据类型

字符串的拼接：

/**

 *  这是第一次课数据基本类型

 * @author 

 *

 */



public class App1{

public static void main(String[] args){

String name ="马峰";

//      删删，双双(""),加加(++),填填(需要更换的标题)

System.out.println("wosnin ssad\'"+name+"\'");

}

}

3.2关键字与标识符

关键字

关键字是Java语言中被赋予特定含义的一些单词，他们在程序中有着不同的用途，因此java语言是不允许用户对关键字赋予其他的含义。Java语言定义的关键字如下（注意：都是小写）：

正在上传…重新上传取消

标识符

含义

标识符是用来表示变量名、类名、方法名、数组名和文件名的有效字符序列。标识符要满足如下规定：

标识符可以由字母、数字和下划线（-），美元符号（$）等组合而成
标识符必须以字母、下划线或美元符号开头，不能以数字开头

3.3常数

常量存储是在程序中不能被修改的固定值，即常量是在程序运行的整个过程中保持其值不改变的量。Java语言中的常量也是有类型的，包括整型、浮点型、布尔型、字符型和字符串型。

整型常量

整型常量可以用来给整型变量赋值，整型常量可以采用十进制，八进制或十六进制表示。

整型常量按照所占的内存长度又可以分为一般整型常量和长整型常量。

浮点型常量

浮点型常量表示的是可以含有小数部分的数值常量。根据占用内存长度的不同，可以分为一般浮点（单精度）长度和双精度浮点常量两种。

布尔型常量

布尔型常量也称为逻辑型常量，包括true和false，分别代表真和假。

字符型常量

字符型常量是用一对单引号括起来的单个字符。如‘a’，‘9’。字符可以直接是字母表中的字符，也可以是转义符。

字符串常量

字符串常量是用双引号括起来的一串若干个字符（可以是0个）。字符串中也可以包括转义符，但标志字符串开始和结束的双引号必须在源代码的同一行上。

常量的声明

常量声明的形式与变量的声明形式基本一样，只需要关键字final标识，通常final写在最前面。例如：

Final int MAX=10;

Final float PI=3.14f;

3.4 变量

在程序中使用变量的值大多是需要经常变换的数据，用常数值表示显然是不够的。因此，每一种计算机语言都使用变量来存储数据，变量的值在程序运行中是可以改变的，使用变量的原则是“先声明后使用”，即变量在使用前必须声明。

变量声明格式：

一个变量由标识符，类型和可选的初始值共同定义。变量声明的格式如下：

类型变量名[=初值]]，变量名[=初值].......];

变量初始化：

在声明变量的同时也可以对变量进行初始化，即初始值。如：

int i=0；

变量的赋值

当声明一个变量并没有赋值或需要重新对变量赋值时，就需要使用赋值语句。Java语句的赋值语句同其他计算机的赋值语句相同，其格式为：

变量名=值；

下面举例说明：

byte b=55;

short s=128;

boolean t=true;

int x,y=8;

3.5.数据类型转换

Java语言的数据类型在定义时就已经确定，因为不能随意转换成其他的数据类型，但Java语言容许用户有限度地做类型转换处理，这就是所谓的数据类型转换，简称类型转换。

数值型不同类型数据的转换

自动类型转换

在程序中已经定义好的数值型的变量，若是想以另一种数值类型表示时，Java语言会在下列条件同时成立时，自动进行数据类型转换。

转换前的数据类型与转换后的类型兼容。
转换后数据类型的表示范围比转换前的数据类型的表示范围大。
转换从短到长的优先级为：

Byte→short→char→int→long→float→double

强制类型转换

如果要将长的数据类型转换成短的数据时，就要进行强制类型转换。强制类型转换格式如下：

（欲转换的数据类型）变量名

这种强制类型转换，因为是直接编写在程序代码中的，所以也称为显示转换。接过强制类型转换，将得到一个括号里声明的数据类型的数据。

3.6由键盘输入数据

Scnner使用的基本步骤

导包

import java.util.Scanner;

//导包的动作必须出现在类定义上

创建对象

Scanner sc =new Scanner(System.in);

上面这个格式中，只有sc是变量名，可以变，其他都不允许变。

接收数据

int i = sc.nextInt();

上面这个格式里面，只有i是变量名，可以变，其他的都不变。

例如：

package APP;

/**

 * 数据的输入

 * 导包

 * import java.util.Scanner;

 * 创建对象

Scanner sc =new Scanner(System.in);

 * 接收数据

 * int i = sc.nextInt();

 *

 *

 */

import java.util.Scanner;



public class APP1 {

public static void main(String[] args){

//创建对象

Scanner sc =new Scanner(System.in);

//接收对象

int i = sc.nextInt();

//输出数据

System.out.println("i:"+i);

}

}

流程控制

4.1顺序结构

顺序结构是最简单的流程控制结构。顺序结构就是程序从上到下一行一行执行的结构，中间没有判断和跳转，直到程序结束。在顺序结构中程序里面的语句将按照他们书写的先后顺序依次执行。

顺序结构执行流程图：

正在上传…重新上传取消

例如：

package APP;



public class www {

public static void main(String[] args){

System.out.println("开始");

System.out.println("语句1");

System.out.println("语句2");

System.out.println("语句3");

System.out.println("结束！");

}



}

4.2 分支语句

4.2.1 if条件语句

if语句格式 1：

正在上传…重新上传取消

执行流程：

首先计算关系表达试的值
如果关系表达式的值为true就执行语句体
如果关系表达式的值为false就不执行语句体
继续执行后面的语句内容

例如：

package APP;



public class www {

public static void main(String[] args){

System.out.println("开始");

//定义两个变量

int a =10;

int b=20;

//需求  判断a和b的值是否相等，如果相等，就输出a=b;

if(a==b){

System.out.println("a=b");

}

int c=10;

if(a==c){

System.out.println("a=c");

}

System.out.println("结束");

}



}

if语句格式2：

正在上传…重新上传取消

执行流程：

首先计算关系表达式的值
如果关系表达式的值为true就执行语句体1
如果关系表达式的值为false就执行语句体2
继续执行后面的语句内容

例如：

package APP;



public class dfdfsgs {

public static void main(String[] args){

System.out.println("开始");

// 定义两个变量

int a=5;

int b=7;

//需求： 判断a是否大于b；如果是，就输出a>b;如果不是就输出a<b;

if(a>b){

System.out.println("a>b");

}else{

System.out.println("a<b");

}

System.out.println("结束");

}

}

if语句结构体3：

正在上传…重新上传取消

执行流程：

首先计算关系表达式1的值
如果值为true就执行语句体1；如果为false就计算关系表达式2的值
如果值为true就执行语句体2；如果为false就计算关系表达式3的值
.................
如果没有任何的关系表达式为true，就执行语句体n+1。

数组结构

5.1什么是数组

什么是数组？

数组是存储在一个连续的内存块中的元素集合。

数组中的每个元素必须是相同的数据类型，并且通过索引进行区分。数组中的第一个元素的索引为0。

数组相当于一个容器，之前我们也学习了基本类型的变量，也可以看成一个容器，但是之前的容器，我们发现只能保存单个的值，不能解决复杂的问题。但是数组也有缺陷，数组只能放入同一类型的数据在数组中。

为什么要用数组？

①单一值类型变量有时候很难满足应用程序的设计要求。

②数组类型变量可以同时存储多个同类型基础数据类型变量或对象。

1．声明一个数组变量；

语法：

数据类型[] 数组变量名；//推荐

或

数据类型数组变量名[];

例如：

int[] sums;或 int sums[];

2．使用new关键字初始化数组，并指定数组的大小。

语法：

数组类型 []数组变量 = new 数组类型[数组长度];

例如：

int [] sums = new int[20];

再赋值： sums[0]=1;

或

int [] sums=new int[]{1,2};创建长度为2的int数组对象，同时赋初始值

3.声明并赋值方式

int[] x={1,2,3,4,5}；

4.访问数组：通过变量名[] 的方式访问。

int [] sums = new int[20];

sums[0] = 1;

sums[1] = 2;

…….

sums[19] = 20;

为了给20个元素赋值，就需要20条语句。显然，用for循环赋值更方便。

for(int i = 0; i < 20; i++){

  sums[i] = i + 1;

}

5.数组的长度:

①因为数组对象的内存空间是连续的。所以在分配空间的时候必须知道数组的长度。而一旦分配好后就不能修改了。

②在使用访问数组元素时，特别要注意，不要超出数组所分配的空间。否则会出现运行时异常：ArrayIndexOutOfBoundsException（演示）

③Java语言的数组与其它语言的数组的不同之处在于：Java中的数组是对象。这样做的好处之一为：Java中的每个数组都有一个length属性来代表数组的大小，可以极大地减少数组访问越界的可能性。

5.2数组赋值：

因为数组的大小是固定的，所以在使用数组时，经常不得不创建一个更大或更小的数组，然后将已存在的数组的内容复制到新的数组中。

①创建一个新数组，然后使用for循环挨个拷贝（演示）

int [] sums;

sums=new int[10];

int[] sums2={1,2,3,4,5};

for (int i = 0; i < sums2.length; i++) {

sums[i]=sums2[i];

}

for (int i = 0; i <sums.length; i++) {

System.out.println(sums[i]);

}

②System类中的静态方法arraycopy()。(演示)

public static void main(String[] args) {

int [] arr ={1,2,3};//源数组

int [] arr2 = {0,0,0,0,0};//目标数组

//用System类里的方法拷贝数组的元素；参数依次为：源数组/原数组的起始位置/目标数组/目标数组的起始位置/拷贝元素个数

System.arraycopy(arr, 0, arr2, 0, 3);

for (int i = 0; i < arr2.length; i++) {

System.out.println(arr2[i]);

}

}

③用Arrays类中的copyOf方法

public static void main(String[] args) {

int [] arr ={1,2,3};//源数组

// 用Arrays工具类里的方法：第二个参数为新数组的长度，可以大于原数组，没有的值使用默认值

int[] copyOf = Arrays.copyOf(arr, 6);

for (int i = 0; i < copyOf.length; i++) {

System.out.println(copyOf[i]);

}

}

5.3一维数组

package edu.class2;

import java.util.Arrays;

public class TEXT {

public static void main(String[] arg) {

/**

 * 一维数组

 */

String str="61";

//1.声明数据

String[] strs;

//2.分配空间

strs = new String[3];

//3.赋值

strs[0]="cc";

strs[1]="bb";

/**

 *  for循环在知道起始值和终止值是使用最佳

 */

//把数组打印一下

//打印数字的方式 Assays.tostring(数组名称）

System.out.println(Arrays.toString(strs));

}

}

5.4二维数组

我们学习了一维数组。其实我们可以看成一维数组就是一个袋子。这个袋子只能放同类型的东西。二维数组怎么来想？其实二维数组，就可以当成在袋子外边再套一个袋

一维数组语法：【元素类型】[ ] 数组名称 = new 【元素的类型】[数组大小]

二维数组的语法：【元素类型】[ ][ ] 数组名称 = new 【元素类型】 [行数] [列数]

例如：

一维数组：int[] a = new int[5];

二维数组：int[][] b = new int[5][5];

三维数组：int[][][] c = new int[5][5][5];

依次类推……

；

定义和创建二维数组的方式：

int[][] yan = new int[10][20];

int[][] yan1 = { {1,3},{4,5,8},{88,77},{10}};

用嵌套for循环遍历二维数组：

例子：

int[][] yan = { {1,3},{4,5,8},{88,77},{10}};

    for (int i = 0; i < yan.length; i++) {

for (int j = 0; j < yan[i].length; j++) {

System.out.print(yan[i][j]+" ");

}

System.out.println();

}

练习

求一个数组中的最大/小值

正在上传…重新上传取消

2.数组排序升序/降序

2.1冒泡排序法：

正在上传…重新上传取消

package edu.class2;

import java.util.Arrays;

public class TEXT {

public static void main(String[] arg) {

/*

 * 二维数组

 */

//1.声明数组

String [][] strs;

//2.分配空间

strs =new String[2][3];

//3.赋值

strs[0][0]="我是[0][0]";

strs[0][1]="我是[0][1]";

strs[0][2]="我是[0][2]";

strs[1][0]="我是[1][0]";

strs[1][1]="我是[1[1]";

strs[1][2]="我是[[1][2]";

//二维数组的输出（遍历数组）;

//strs.length表示二维数组的长度（即第一个中括号的值：2）

for(int  i=0;i<strs.length;i++){

for(int j=0;j<strs[i].length;j++) {

System.out.println(strs[i][j]);

}

}

}

}

/**

 *  例题

 **/

package app1

public static void main(String[] args){

/**

 * 请手写代码创建一个（）维数组，其类型为（）

 * 长度为【2】【3】；【3】

 * 要求对其进行赋值，并完成输出

 */

//1.声明数组

char [][] str;

//2.分配空间（确定数组的长度）

str =new char[2][3];

//赋值

//str[2][3]='a';

for (int i=0;i<str.length;i++){

for(int j=0;j<str[i].length;j++){

str[i][j]='a';

System.out.println(str[i][j]);



}

}

}

类与对象

6.1类的基本概念

C 语言是典型的结构化（面向过程）编程语言，函数是C语言的基本构造单元，所以C程序由一到多个函数组成。

Java是一门面向对象的语言，类是java的基本构造单元，java程序的所有的语句都在类中。

所谓面向对象，是一种看待问题和处理问题的方式。

面向对象编程思想中包含两个基本概念：对象（object）和类（class）;

所谓对象，就是现实世界中的“东西”/“物体”；

对象有两个主要组成部件：属性和行为；

属性：表示对象是由什么组成的；

行为：指的是对象可以做什么；

抽象出对象的属性和行为，按此标准将对象分类，就得到了类的概念；类就是一类事物的统称。如：人类是对所有人的统称；

在面向对象的过程中，类是生成对象的模板。

如建筑设计图----房子

模具------玩具

类-------对象

6.2定义类

类的一般结构

定义类又称为声明类，其一般的语法结构如下：

语法：

[类修饰符] class 类名称

{

正在上传…重新上传取消[修饰符]数据类型成员变量名称;

. 声明成员变量

正在上传…重新上传取消 [修饰符]返回值的数据类型方法名（参数1,参数2,...,参数n）

{

语句序列;

{ 声明成员方法

return[表达式];

}

Java中的类用关键字class声明。Java源代码文件中只能包含一公用（public）类，文件名必须与公用类的类名相同，文件扩展名为“.java”。

修饰符：public、private、protected、不加(默认的，default)；

类只能使用不写或者public作为修饰符

类修饰符分为公共访问控制符、抽象类说明符、最终类说明符和缺省访问控制符四种。各修饰符的含义如表6.1所示

正在上传…重新上传取消

一个类可以有多个修饰符，且无先后顺序之分，但abstract和final相互对立，所以不能同时应用在一个类的定义中。

成员变量

一个类的成员变量描述了该类的内部信息，一个成员变量可以是基本类型变量，也可以是对象、数组等其他引用型数据。成员变量的格式如下：

[修饰符] 变量类型变量名[=初值]；

成员变量的修饰符有访问控制符、静态修饰符、最终修饰符、过渡修饰符和易失修饰符等，其含义如表所示。

正在上传…重新上传取消

成员方法

类的方式是用定义对类的成员变量进行操作的，是实现类内部功能的机制，同时也是类与外界进行交互的重要窗口。声明方式的语句格式如下：

[修饰符] 返回值的数据类型方式名（参数1,参数2,...,参数n）

{

语句序列；

return（表达式）；

}

成员变量与局部变量的区别

1：成员变量直接定义在类中。

局部变量定义在方法中，参数上，语句中。

2：成员变量在这个类中有效。

局部变量只在自己所属的大括号内有效，大括号结束，局部变量失去作用域。

3：成员变量存在于堆内存中，随着对象的产生而存在，消失而消失。

局部变量存在于栈内存中，随着所属区域的运行而存在，结束而释放。

6.3 对象的创建与使用

1.创建对象

类名对象名 = new 类名()；

Telphone phone = new Telphone;

2.使用对象

引用对象的属性：对象名 . 属性

phone.screen = 5; // 给screen属性赋值5

　　引用对象的方法：对象名 . 方法名()

phone.sendMessage(); // 调用sendMessage()方法

实例：

创建两个 .java文件

Telphone.java



// 1.定义一个类public class Telphone {

    // 2.属性（成员变量）有什么

    float screen; // 屏幕

    double cpu;       // cpu

    int mem;       // 内存

    // 3.方法 干什么

    void call(){

        System.out.println("Telphone有打电话的功能~~~");

    }

    void getMessage(){

        

        System.out.println("screen:"+screen +

                           "\ncpu:"+cpu +

                           "\nmem:"+cpu +

                           "\nTelphone有发短信的功能~~~");

    }

}



InitailTelphone.java



package Day8_09;

public class InitailTelphone {



    public static void main(String[] args) {

        // TODO Auto-generated method stub 

        /*

         *    Telphone     : 对象的类型，对象的类就是对象的类型

         *    phone        ：实例化的对象的名字

         *    new Telphone() ：实例化一个对象

         */

        Telphone phone = new Telphone();

        phone.screen = 4.5f; // 给属性（成员变量）赋值的时候要看清成员变量的类型

        phone.cpu = 2.50d;

        phone.mem = 6;

        phone.call();//调用打电话的方法

        phone.getMessage();//调用发短信的方法    }



}

6.4参数的传递

方式既可以有返回值，也可以也参数，如area（）方法与volume()方法。当方法不需要传递任何参数时，方式的括号内什么也不用写。但事实上，方法中可以具有各种类型的参数，以满足各种不同的计算要求。

以变量为参数调用方法

调用方法并传递参数时，参数其实就是方法的自变量，所以参数要放在方法的括号内来进行传递。括号内的参数可以是数值型、字符串型，甚至是对象。Set变量名称（）方法便会接收传递进来的三个参数，然后在该方法体内将这三个参数赋值给相应的成员变量里面。get变量名称可以语句调用。

第七章 java语言类的特性

7.1类的私有成员与公共成员

私有成员

如果没有一个机制来限制对类中成员的访问，则很有可能会造成错误的输入。为了防止这种情况的发生，java语言提供了私有成员访问控制修饰符private。也就是说，如果在类的成员声明的前面加上修饰符private，则就无法从该类的外部访问到该类内部的成员，而只能被该类自身访问和修改，而不能被任何其他类（包括该类的子类）获取或引用，因此达到了对数据最高级别保护的目的。

封装（面向对象特征之一）：是指隐藏对象的属性和行为，仅对外提供公共访问方式。

好处：将变化隔离；便于使用；提高重用性；安全性。

封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。

封装的方式：用private 声明成员变量。那么它就不能被其他类访问，从而将其隐藏；

要给封装数据提供公开的方式：

1）访问数据：公开的访问器 public 【返回值类型】 getUserName(){}

2）修改数据：公开的修改器 public void setUserName（）；

this:代表对象。就是所在函数所属对象的引用。

this到底代表什么呢？哪个对象调用了this所在的函数，this就代表哪个对象，就是哪个对象的引用。

开发时，什么时候使用this呢？

在定义功能时，如果该功能内部使用到了调用该功能的对象，这时就用this来表示这个对象。

this 还可以用于构造函数间的调用。

调用格式：this(实际参数)；

this对象后面跟上 . 调用的是成员属性和成员方法(一般方法)；

this对象后面跟上 () 调用的是本类中的对应参数的构造函数。

注意：用this调用构造函数，必须定义在构造函数的第一行。因为构造函数是用于初始化的，所以初始化动作一定要执行。否则编译失败。

下面举例说明：

一：private 保护类中的变量

Person类

正在上传…重新上传取消

package 类;

public class Person {

    String name;//    使用private修饰的变量，只能本类中访问，导包导入后，不能使用 类似于python里面的 _age = 10

    private int age;

    public void call(){

        System.out.println("我叫："+name + "，年龄："+age);

    }//    为了让外部能够访问到age这个属性,需要使用特定的方法，python里面也有//    set是设置，通过暴露这个方法让外部来设置私有变量

    public void setAge (int num){

        age = num;

    }

    public void setName(String flag){

        name = flag;

    }//    get是获取，通过暴露着这个方法让外部来获取私有变量

    public String getName(String flag){

        name = flag;

        return name;

    }



}

正在上传…重新上传取消

外部访问Person类

正在上传…重新上传取消

package 类;

public class Demo_Person {

    public static void main(String[] args) {

        Person people = new Person();//        age是private，外部不能导入//        System.out.println(people.age);//        类中设置专门的方法来改变age

        people.setAge(20);

        people.setName("王小二");

        people.call();//        类中有专门的方法来间接访问类属性

        String name = people.getName("刘德华");

        System.out.println(name);

    }



}

正在上传…重新上传取消

private是访问控制修饰符，用来使用访问控制符来保护对类、变量、方法和构造方法的访问。不能直接访问，但是通过方法可以间接访问类中的变量

python里面是通过__age，两个下划线来定义私有变量的，外界也是无法访问

Person.py

class PersonDemo():

__age = 10

__name = "张学友"

Use_Person.py

正在上传…重新上传取消

from python知识点 import Person

p = Person.PersonDemo()print(p.__age)print(p.__name)

# 结果Traceback (most recent call last):

File "F:/pycharm测试功能文件夹/python知识点/Use_Person.py", line 4, in <module>

print(p.__age)

AttributeError: 'PersonDemo' object has no attribute '__age'

正在上传…重新上传取消

如果外界要访问和修改，必须通过类中的set__age和set__name/get__age和get__name

Person.py

正在上传…重新上传取消

class PersonDemo():

__age = 10

__name = "张学友"

def get__age(self):

return self.__age

def get__name(self):

return self.__name

def set__age(self,num):

self.__age = num

def set__name(self,nick):

self.__name = nick

正在上传…重新上传取消

Use_Person.py

正在上传…重新上传取消

from python知识点 import Person

p = Person.PersonDemo()print(p.get__age())print(p.get__name())

p.set__age(20)

p.set__name("刘德华")print(p.get__age())print(p.get__name())

# 结果

张学友20

刘德华

正在上传…重新上传取消

公共成员

既然在类的外部无法访问到类内部的私有成员,那么Java就必须提供另外的机制，使得私有成员得以通过这个机制来供外界访问。解决此问题的办法就是创建公共成员。为此,Java提供了公共访问控制符public。如果在类的成员声明的前面加上修饰符public,则表示该成员可以被所有其他的类所访问。由于public修饰符会造成安全性和数据封装性的下降,所以一般应减少公共成员的使用。下面举例说明如何利用公共方法(也称公共成员方法)来访问私有成员变量。

7.2 方法的重载

方法的重载是实现“多态”的一种方法。在面向对象的程序设计语言中，有一些方法的含义相同,但带有不同的参数，这些方法使用相同的名字，这就叫方法的重载(overloading)。也就是说，重载是指在同一个类内具有相同名称的多个方法,这多个同名方法如果参数个数不同，或者是参数个数相同但类型不同，则这些同名的方法就具有不同的功能，注意:方法的重载中参数的类型是关键，仅仅是参数的变量名不同是不行的。也就是说参数的列表必须不同,即:或者参数个数不同，或者参数类型不同，或者参数的顺序不同。

正在上传…重新上传取消

普通方法的重载

正在上传…重新上传取消

重载方法及构造器的调用

正在上传…重新上传取消

总结：private只有本类可以访问

不写(default):同包

protected:同包+不同包子类。

public :全部

例:

public class User {

//对成员变量用private封装

private String userName;

private String password;

//公开访问器

public String getUserName() {

return userName;

}

//公开修改器

public void setUserName(String userName) {

this.userName = userName;

}

//公开访问器

public String getPassword() {

return password;

}

//公开修改器

public void setPassword(String password) {

this.password = password;

}

}

7.3构造方法

前面所介绍的由Cylinder类所创建的对象,其成员变量都是在对象建立之后,再由相应的方法来赋值。如果一个对象在被创建时就完成了所有的初始化工作,将会很简洁。因此,Java语言在类里提供了一个特殊的成员方法————构造方法。

构造方法的作用与定义

构造方法(constructor)是一种特殊的方法,它是在对象被创建时初始化对象成员的方法。构造方法的名称必须与它所在的类名完全相同。构造方法没有返回值,但在定义构造方法时，构造方法名前不能用修饰符void来修饰，这是因为一个类的构造方法的返回值类型就是该类本身。构造方法定义后,创建对象时就会自动调用它,因此构造方法不需要在程序中直接调用，而是在对象创建时自动调用并执行。这一点不同于一般的方法，一般的方法在用到时才调用。

由此可以看出,构造方法是种特殊的、与类名相同的方法，专门用于在创建对象时完成初始化工作。构造方法的特殊性主要体现在如下几个方面:

构造方法的方法名与类名相同;
构造方法没有返回值,但不能写void;
构造方法的主要作用是完成对类对象的初始化工作;
构造方法一般不能由编程人员显式地直接调用，而是用new来调用;
在创建-一个类的对象的同时，系统会自动调用该类的构造方法为新对象初始化。

7.3.3构造方法的重载

一般情况下，每个类都有一个或多个构造方法。但由于构造方法与类同名,所以当一个类有多个构造方法时，则这多个构造方法可以重载。我们已经知道，只要方法与方法之间的参数个数不同，或参数的类型不同,便可定义多个名称相同的方法，这就是方法的重载。因此我们不难定义出构造方法的重载。构造方法的重载，可以让用户用不同的参数来创建对象。

7.4静态变量

2.1static：★★★★ 关键字（掌握）

是一个修饰符，用于修饰成员(成员变量和成员函数)。

用法：

1.修饰变量：静态变量--也叫类变量--直接用类名称.属性调用--不需要创建对象；

2，修饰方法：静态方法--也叫类方法--直接用类名称.方法（参数）调用--不需要创建对象；

特点：

1，想要实现对象中的共性数据的对象共享。可以将这个数据进行static修饰。

2，被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态成员方式。

3，静态随着类的加载而加载。而且优先于对象存在。

弊端：

1，有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象间的共享数据。这样对事物的描述就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。

2，静态方法只能访问静态成员，不可以访问非静态成员。

(这句话是针对同一个类环境下的，比如说，一个类有多个成员（属性，方法，字段），静态方法A，那么可以访问同类名下其他静态成员，你如果访问非静态成员就不行)

因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。

3，静态方法中不能使用this，super关键字。

因为this/super代表对象，而静态在时，有可能没有对象，所以this无法使用。

什么时候定义静态成员呢？或者说：定义成员时，到底需不需要被静态修饰呢？

成员分两种：

1，变量。（数据共享时静态化）

该成员变量的数据是否是所有对象都一样：

如果是，那么该变量需要被静态修饰，因为是共享的数据。

如果不是，那么就说这是对象的特有数据，要存储到对象中。

2，函数。（方法中没有调用特有数据时就定义成静态）

如何判断成员函数是否需要被静态修饰呢？

只要参考该函数内是否访问了对象中的特有数据：

如果有访问特有数据，那方法不能被静态修饰。

如果没有访问过对象特有数据，那么这个方法可以被静态修饰。

成员变量和静态变量的区别：

1，成员变量所属于对象。所以也称为实例变量。

静态变量所属于类。所以也称为类变量。

2，成员变量存在于堆内存中。

静态变量存在于方法区中。

3，成员变量随着对象创建而存在。随着对象被回收而消失。

静态变量随着类的加载而存在。随着类的消失而消失。

4，成员变量只能被对象所调用。

静态变量可以被对象调用，也可以被类名调用。

所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据。

静态的注意：静态的生命周期很长，一直着占用内存。

主函数是静态的：

public：访问权限最大。

static：不需要对象，直接类名即可。

void：主函数没有返回值。

main：主函数特定的名称。

(String[] args)：主函数的参数，是一个字符串数组类型的参数，jvm调用main方法时，传递的实际参数是 new String[0]。

jvm默认传递的是长度为0的字符串数组，我们在运行该类时，也可以指定具体的参数进行传递。可以在控制台，运行该类时，在后面加入参数。参数之间通过空格隔开。jvm会自动将这些字符串参数作为args数组中的元素，进行存储。

主函数的调用： java 类名告诉jvm去调用该类的main方法；

2.2静态代码块（理解）：

就是一个有静态关键字标示的一个代码块区域。定义在类中。

作用：可以完成类的初始化。

静态代码块随着类的加载而执行，而且只执行一次（new 多个对象就只执行一次）。如果和主函数在同一类中，优先于主函数执行。

static{

     //可以在这里调用静态变量/静态方法

System.out.println("静态代码块里");

}

2.3实例初始化块（理解）

又叫做实例代码块或构造代码块

类的对象每实例化一次，就执行一次。实例代码块在构造器之前执行，用于对实例初始化。

{

System.out.println("实例代码块里");

}

静态代码块、构造代码块、构造函数同时存在时的执行顺序：静态代码块 à 实例初始化块 à 构造函数；

3.内部类（理解）

在类的内部定义一个类，这个内部的类叫做内部类，内部类所在的类叫做外部类；

内部类只能在外部类的内部使用。

类型	说明
成员内部类	作为外部类的非静态成员,内部类中可以直接访问外部类的静态和非静态成员。内部类的对象的创建依赖外部类的对象。
静态内部类	作为类的静态成员。在静态内部类中只能使用外部类的静态成员。静态内部类的对象可以直接创建。
局部内部类	存在于某个方法内部的类在静态方法中创建的内部类中只能调用外部类的静态成员；局部内部类可以调用外部类的静态和非静态成员；局部内部类的对象，只能在所在方法内创建和使用
匿名内部类	存在于某个类的内部，但是无类名的类；此匿名内部类是前面new的类的子类，可在里面重写父类的方法或变量

内部类编译后的文件名为：“外部类名$内部类名.class”；

3.1成员内部类

语法：

public  class Outer{//外部类

static int a =10;

int b =20;

public void f(){

System.out.println("在外部类的成员方法f()中");

}



public static void h(){

System.out.println("在外部类的静态方法中");

}



//内部类

class  Inner {

int c =30;

public void plus(){

a=20;//可以直接在内部类使用外部类的静态变量

b=20;//可以直接在内部类使用外部类的成员变量

f();//可以直接在内部类使用外部类的成员方法

h();//可以直接在内部类使用外部类的静态方法

System.out.println(a+" "+b);

}

}





public static void main(String[] args) {

Outer o = new Outer();//先创建外部类对象

Inner in = o.new Inner();//内部类的对象无法直接创建，必须通过外部类的对象创建内部类对象

in.plus();

}

}

3.2静态内部类

public  class Outer{//外部类

static int a =10;

int b =20;

public void f(){

System.out.println("在外部类的成员方法f()中");

}



public static void h(){

System.out.println("在外部类的静态方法中");

}



//内部类

static class  Inner {

int c =30;

public void plus(){

//能在内部类直接访问外部类静态成员，不能直接访问外部类的非静态成员

a=20;//可以直接在内部类使用外部类的静态变量

h();//可以直接在内部类使用外部类的静态方法

System.out.println(a);

Outer out = new Outer();//可以先创建外部类的对象，再用对象调用外部类的成员变量和成员方法

int c =out.b;

System.out.println(c);

}

}



//主函数

public static void main(String[] args) {

Inner in = new Inner();//静态内部类的对象可直接创建

in.plus();

}

}

如果内部类被静态修饰，相当于外部类，会出现访问局限性，只能访问外部类中的静态成员。

注意；如果内部类中定义了静态成员，那么该内部类必须是静态的。

3.3局部内部类

定义在方法的内部，只能在方法的内部使用，一旦所在的方法执行完毕，局部内部类就会在内存中被清除。

public class Outer {// 外部类

static int a = 10;

int b = 20;



public void f() {

final int c = 30;

System.out.println("在方法f中");

//内部类

class Inner {

public void plus() {

//可以直接使用外部类的静态变量和非静态变量

h();//可以直接使用外部类的静态方法

System.out.println(a+b); System.out.println(c);//只能调用所在方法中final修饰的变量

}



}

//只能在内部类所在的方法内创建内部类的对象

Inner in = new Inner();

in.plus();

}



public static void h() {

System.out.println("在外部类的静态方法中");

}



// 主函数

public static void main(String[] args) {

Outer out =new Outer();

out.f();



}

}

3.4匿名内部类

匿名内部类（对象）：没有名字的内部类。就是内部类的简化形式。一般只用一次就可以用这种形式。匿名内部类其实就是一个匿名子类对象。想要定义匿名内部类：需要前提，内部类必须继承一个类或者实现接口。

匿名内部类的格式：new 父类名 (){ 定义子类成员或者覆盖父类方法 }；

public class Person {//外部类

    public void eat(){

    }

    

    //主函数

    public static void main(String[] args) {

        Person p = new Person() {//匿名内部类，创建了一个Person类的子类，并创建了一个子类对象

            public void eat() {//在这个子类中重写了Person类的eat方法

                System.out.println("eat something");

            }

        };

        p.eat();//调用的是子类的方法，所以输出 eat something

    }

}

java语言的输入输出与文件处理

10.1 java语言的输入输出

10.1.1流的概念

流：可以理解数据的流动，就是一个数据流。IO流最终要以对象来体现，对象都存在IO包中。是指计算机各部件之间的数据流动。

流也进行分类：

1：输入流（读）和输出流（写）。

2：因为处理的数据不同，分为字节流和字符流。

字节流：处理字节数据的流对象。设备上的数据无论是图片或者dvd，文字，它们都以二进制存储的。二进制的最终都是以一个8位为数据单元进行体现，所以计算机中的最小数据单元就是字节。意味着，字节流可以处理设备上的所有数据，所以字节流一样可以处理字符数据。

注意：流的操作只有两种：读和写。

字节流：InputStream OutputStream

字符流：Reader Writer

正在上传…重新上传取消

输入字节流：

-----------| InputStream 所有输入字节流的基类抽象类

-----------------| FileInputStream 读取文件数据的输入字节流

//1.将文件用对象表示，该文件必须存在

File f = new File("D://test.txt");

//2.把文件对象给字节输入流

FileInputStream fis = new FileInputStream(f);

//3.创建一个字节输出流，输出到指定文件，若存在该文件则覆盖，不存在就新建

FileOutputStream fos = new FileOutputStream("D://test2.txt");

//4.声明一个int变量

int i ;

//5.边读边写

while((i=fis.read())!=-1){//读到末尾返回-1，否则返回读到的内容

fos.write(i);

}

//4.声明一个数组缓存区

byte [] bs = new byte[1024] ;

//5.边读边写

        int i ;

while((i=fis.read(bs))!=-1){//读到末尾返回-1，否则返回读到的内容

  fos.write(bs,0,i);

}

fos.close();

有缓冲区的方式：较为高效，减少磁盘损耗，可自定义缓冲区大小。

-----------------| BufferedInputStream 缓冲输入字符流该类出现的目的是为了提高读取文件数据的效率。这个类其实只不过是在内部维护了一个8kb的字节数组而已。

//1.将文件用对象表示，该文件必须存在

File f = new File("D://test.txt");

//2.把文件对象给字节输入流

FileInputStream fis = new FileInputStream(f);

//3.创建缓冲字节输入流  缓冲区8K

BufferedInputStream bis = new BufferedInputStream(fis);

//4.创建缓冲字节输出流  缓冲区8K

BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("d://test3.txt"));

int i ;

//5.便读编写   从缓冲区里读出来

while ((i=bis.read())!=-1){

bos.write(i);//写到缓冲区里

}

输出字节流：

-----------| OutputStream 所有输出字节流的基类。抽象类。

----------------| FileOutputStream 向文件输出数据的输出字节流

----------------| BufferedOutputStream 缓冲输出字节流该类出现的目的也是为了提高向文件写数据的效率。这个类的也只不过是在内部维护了一个8kb的字节数组而已。

输入字符流:

字符流 : 字符流 = 字节流 + 编码

---------| Reader 所有输入字符流的基类。抽象类。

----------------| FileReader 读取文件数据的输入字符流。

//1.将文件用对象表示，该文件必须存在

File f = new File("D://test.txt");

//2.把文件对象给字符输入流

FileReader fr = new FileReader(f);

//3.创建一个字符输出流

FileWriter fw = new FileWriter("d://test100.txt");

//4.创建一个char数组作为缓冲区

char [] c = new char[1024];

//5.便读边写

while(fr.read(c)!=-1){

fw.write(c);//写到字符输出流

//打印到控制台

for (int j = 0; j < 100; j++) {

System.out.print(c[j]);

}

}

----------------| BufferedReader 缓冲输入字符流该类出现的目的是为了提高读取文件数据的效率与拓展FileReader的(readLine)功能。这个类的也只不过是在内部维护了一个8kb的字符数组而已。

//1.将文件用对象表示，该文件必须存在

File f = new File("D://test.txt");

//2.把文件对象给缓冲字符输入流

BufferedReader br = new BufferedReader(new FileReader(f));

//3.创建缓冲字符输出流

BufferedWriter bw = new BufferedWriter(new FileWriter("d://a.txt"));

//4.边读边写

int i ;

while ((i=br.read())!=-1){//从读取缓冲区读

bw.write(i);//写到输出流的缓冲区

}

输出字符流:

---------| Writer 所有输出字符流的基类。抽象类

----------------| FileWriter 向文件输出数据的输出字符流

----------------| BufferedWriter 缓冲输出字符流该类出现的目的是为了提高写文件数据的效率与拓展FileWriter的(newLine)功能.

主要的方法：循环读/写

  int read() 读取一个字节数据

  int read(byte[]) 读取一个指定大小的字节数组数据



  void write(int) 写入一个字节数据

  void write(byte[]) 写入一个字节数组大小的数据

flush();刷新

close();关闭

close()和flush()的区别：

flush()：将缓冲区的数据刷到目的地中后，流可以使用。

close()：将缓冲区的数据刷到目的地中后，流就关闭了，该方法主要用于结束调用的底层资源。这个动作一定做。

流的操作规律：

1，明确源和目的。

数据源：就是需要读取，可以使用两个体系：InputStream、Reader；

数据汇：就是需要写入，可以使用两个体系：OutputStream、Writer；

2，操作的数据是否是纯文本数据？

如果是：数据源：Reader

数据汇：Writer

如果不是：数据源：InputStream

数据汇：OutputStream

3，虽然确定了一个体系，但是该体系中有太多的对象，到底用哪个呢？

明确操作的数据设备。

数据源对应的设备：硬盘(File)，内存(数组)，键盘(System.in)

数据汇对应的设备：硬盘(File)，内存(数组)，控制台(System.out)。

4，需要在基本操作上附加其他功能吗？比如缓冲。

如果需要就进行装饰。以提高效率！

转换流

InputStreamReader(字节输入流) 将字节输入流转为字符输入流

OutputStreamWriter(字节输出流) 将字符输出流转为字节输出流

转换流可以将字节转成字符，原因在于，将获取到的字节通过查编码表获取到指定对应字符。

转换流的最强功能就是基于字节流 + 编码表。

如果需要制定码表，必须用转换流。

转换流 = 字节流+编码表。

转换流的子类File = 字节流 + 默认编码表。

凡是操作设备上的文本数据，涉及编码转换，必须使用转换流。

从控制台读写：

//从控制台读取数据

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

//每次读一行

String str = br.readLine();

//输出到控制台

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

bw.write(str);

bw.flush();

对象流

要读写的对象的类得实现Serializable接口。

使用ObjectOutputStream将对象拆成字节序列的过程，称为对象序列化；

使用ObjectInputStream 将字节序列还原成对象的过程，称为对象反序列化；

属性和类名可被序列化；

静态属性/方法/transient修饰的属性不可序列化；

多线程

11.1线程的概念

以往开发的程序大多数都是单线程的，即一个程序只有从头到尾的一条执行路径。然而现实世界中的很多过程都是具有多条途径同时运转的特征。例如，我们可以一边喝咖啡，一边听音乐；再如，一个网络服务器可能要同时处理几个客户的请求等。

多线程

指同一个进程中同时存在几个执行体，按几条不同的执行路径同时工作的情况。如QQ,浏览器；

程序

程序是指含有指令和数据的文件，被存储在磁盘或者其他的数据存储设备中，也就是说程序是静态的代码。

进程

一个正在运行的程序通常称为进程，一个进程会有一个单独的内存区域，对于一个cpu而言，同一时间点上只能运行一个进程。所以cpu会在各个进程间来回切换。

多任务

指在一个系统中可以同时运行多个线程，即有多个独立运行的任务，每一个任务对于的一个进程。

线程

每个进程如浏览器，可以有多个线程，每个线程是一个小任务，如下载、浏览网页。可以同时运行多个线程的应用程序叫做多线程应用。

区别：

线程存在于进程中，每个进程都需要操作系统为其分配独立的内存空间。而同一进程中的所有线程都共享同一内存空间和系统资源；

异步：

一个线程执行的时候，其他线程也在执行；

同步：

各个线程依次执行；

在Java中，一个运行的程序至少有两个线程，一个main()线程，一个垃圾回收线程（后台线程）

自定义线程

方式一:

①写一个类继承Thread,并重写其中的run()方法，需要执行的代码放在run方法中，run()方法执行完毕，此线程结束。

public class Thread1 extends Thread {

@Override

public void run() {

for (int i = 0; i < 10; i++) {

try {

Thread.sleep(200);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+":"+i);

}

}



}

}

②在另一个类的main()方法中，创建自定义线程类的对象，用此对象调用start()方法即可启动自定义的线程。

Thread1 t1 = new Thread1();

t1.start();

方式二：

①写一个类实现Runnable接口，并重写run()方法，将要执行的代码放到run()方法中。

public class Thread2 implements Runnable{



@Override

public void run() {

for (int i = 0; i < 10; i++) {

try {

Thread.sleep(200);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+i);

}



}



}

②在另一个类的main()方法中，创建自定义线程类的对象。

创建Thread类的对象，用有参构造器把自定义线程类的对象传进去。

用Thread对象调用start()方法。

Thread2 t3 = new Thread2();

Thread thread = new Thread(t3);

thread.start();

第二章泛型与容器类

12.1 泛型

12.1.1泛型的概念

所谓泛型，就是允许在定义类、接口的时候指定类型形参（类型的形式参数的简称），这个类型形参将在声明变量、创建对象时确定，即传入实际的类型参数，也称类型实参，这实际上就是将数据类型参数化。泛型可以用来定义泛型类、泛型方法和泛型接口。

按照通常的惯例，用T或E这样的单个大写字母来表示类型的参数。泛型类的定义是在类名后面加上<T>,泛型接口的定义是在接口名后面加上<T>，而泛型方法的定义是在方法的返回值类型前面加上<T>，其头部定义分别如下：

泛型的定义:[修饰符] class 类名<T>

泛型接口的定义：[public] interface 接口名<T>

泛型方式的定义:[public][static]<T>返回值类型方法名(T参数)

12.1.2 泛型类及应用

在使用泛型定义的类创建对象时，即在泛型是实例化时，可以根据不同的需求给出类型参数T的具体类型。而在调用泛型类的方法传递或返回数据类型时可以不用进行数据转换，而是直接用T作为类型来代替参数类型或者返值的类型

泛型的定义

class Base<T> {

    T m;



    Base( T t ) {

        m = t;

    }



    public void print() {

        System.out.println("base print ：  " + m);

    }

}



public class test {

    public static void main( String[] args ) {

        Base<String> base = new Base<String>("bb");       // 标准表示法

        Base<String> base1 = new Base("aa");              //兼容老版本，但不安全，会给出警告

        Base<String> base2 = new Base<>("cc");            // 菱形表示法

        base.print();

        base1.print();

        base2.print();

    }

}

12.2容器

12.1.1 java容器框架

从JDK5开始，容器框架全部采用泛型实现，且要存放在java.util包中，容器的框架中的接口及实现这些接口的类的继承关系如图所示。

12.2.3 列表接口List

列表接口List是Collection子接口。他是一种包含有序元素的线性表，其中的元素必须按顺序存放，且可以重复，也可以是空值null。

实现list接口的类主要有两个：链表类LinkedList和数组列表类ArrayList。他们都是线性表。

LinkedList链表类采用链表结构保存对象，使用循环双链表实现List。这种结构向链表中任意位置插入，删除元素时不需要移动其他元素，链表的大小是可以动态增大或减少的，但不具有随机存取的特性。

ArrayList数组列表类使用一维数组实现List，该类实现的是可变数组，允许所有的元素，包括null。具有随机存取特性，插入，删除元素时需要移动其他元素，当元素很多时插入，删除操作的速度比较慢。在向ArrayList中添加元素时，其容量会自动增大，但不能自动缩小，但可以使用trimToSize()方法将数组的容量减小到数组列表的大小。

表12.3和表12.4分别给出了LinkedList<E>类和ArrayList<E>类的构造方法。

使用线性表时通常声明为List<E>类型，然后通过不同的实现类来实例化列表。如：

List<String> list1=new LinkedList<String>();

List<String> list2=new ArrayList<String>();

LinkedList<E>类与ArrayList<E>类大部分方法是继承其父类或者祖先类，除此之外还各自定义了自己的方法，表12.5和表12.6分别给出了LinkedList<E>类与ArrayList<E>类的常用方法。

一飞机大战

代码词解释

JFrame

JFrame是一个顶层的框架类，好比一个窗户的框子。也是一个容器类。这个框子可以嵌入几个玻璃窗。

JFrame 的构造方法：JFrame()

构造一个初始时不可见的新窗体。

JFrame(GraphicsConfiguration gc)

以屏幕设备的指定 GraphicsConfiguration 和空白标题创建一个 Frame。

JFrame(String title)

创建一个新的、初始不可见的、具有指定标题的 Frame。

首先要明白Java是面向对象的语言,也就是把我们所用到的东西都看成对象来处理.有句话叫万事万物皆对象,这个世界上任何的事物都可以看成是一个对象,在Java的世界中也是如此.举个例子说明,你喝水用的杯子跟我喝水用的杯子也许是相同的,更可能是同一个厂家生产的,如果是这样,那么你的杯子是一个对象,我的杯子也是一个对象,而生产杯子的工厂是通过模板来生产出这一个个相同的杯子对象的,在Java中模板就是所谓的类.面向过程与面向对象的区别就在于面向过程注重如何去制造这样一个杯子,也就是工厂要记住制造杯子的过程,然后重复这个过程来生产.而面向对象则是把制造这个杯子需要的材料工艺等等看作是模板也就是杯子类,然后需要杯子的时候只需要调用这个杯子模板即可.那么你所问的这一句实际上就是在Java中最常见的一句通过一个模板来创建一个对象的过程.

JFrame f = new JFrame();

这是规定你所需要的这里给你通过已经定义好了创建对象的调用构造方法来

对象是什么类型的,也模板创建的那模板与对象名固定写法,这进行赋值,也就

就是我们所说的模板个对象起一个那么接下来要是一个关键相当于是我们

对象名,比如对它们实体化, 字,通过new 通过模板来进

你的杯子,我也就是进行赋来告诉Java 行实际的杯子

的杯子等值操作你要创建对象生产

正在上传…重新上传取消

变量

继承

继承：就是类似于我们现实生活中所说的继承财产或继承家族事业中的继承一词意义大致相同。

继承在java中对应的单词是：extends

格式语法：

Public  class  类名 extends 类名{

}

例如：

public class 金枪锁喉 extends Person{

public static void main(Sting[] args){

金枪锁喉 a =new 金枪锁喉();

a.锁喉();

}

public void 锁喉(){

System.out.println("锁喉");

}

}

注意：上面的格式中我们把蓝色字体的类名叫做父类，黑色字体的类名叫做子类，子类可以使用父类的所有方法和属性。

封装

封装：就是指将实现某一个功能但是代码量较多时将其按照功能进行逐个抽取；

面向对象

类

类：表示某一种事物的一种集合，例如：人，包括了男，女，人妖等其中人就是这一类的集合也是总称。

抽象类：不能被实例化，所以只能继承实现其类中的方法；注意：抽象类中的方法都叫做抽象方法（只有方法名、返回值、参数，没有方法体）；

内部类

对象（实例）

对象（实例）：就是指类中的某一个指定的人。例如：男人中的小明就是一个具体的人。

创建对象的格式：

类变量名 = new 类();或者类变量名 = new 类(参数1,参数2,….);

例如：String str = new String();其中str就是String的对象

调用类中的方法

调用类中的方法：

* 1.创建类的对象

* 2.用对象名称.方法名的模式来调用具体事例如下：

public class 综艺节目 {

public void 带货(String 明星,String 地点) {

/**

 * 方法体:代码都写在这里

 */

System.out.println("今天"+明星+"在"+地点+"带货");



}

public static void main(String[] args) {

/**

 * 调用类中的方法：

 * 1.创建类的对象

 * 2.用对象名称.方法名的模式来调用

 */

//创建类的对象

综艺节目 zy = new 综艺节目();

//调用方法

zy.带货("李佳琪", "淘宝");

}

}

变量

成员变量：

成员变量：是指类的属性；

存在于类中可以被类中所有的方法访问到。

public class 综艺节目 {



/**

 * 类的成员属性，成员变量

 */

private String 搞笑;

String 明星;

String BMG;

}

局部变量：

存在于方法中只能作用于当前的方法，即只能作用在当前方法的{}内；

/**

 * 方法：其实就是在说我们类的功能

 */

public void 追星(){

/**

 * 局部变量

 */

String 搞笑1;

String 明星1;

String BMG1;

}

静态变量：

方法

方法的定义：其实就是实现类的功能；

注意：方法内不能定义方法，但是可以调用方法；

构造方法

要求方法名称必须与类名保持一致；不需要写返回类型，也就没有返回值；

而且只要该类的对对象被创建就会自动执行这个方法。

构造方法可以有参数也可无参数；构造方法不唯一，也就是说一个类中可以有多个构造方法；

成员方法

就是在类中的方法；

格式如下：

访问修饰符类型修饰符返回值类型方法名(参数类型参数,参数类型参数….){

代码

return返回值类型;

}

注意：如果没有返回值则返回值类型用void代替，不用写return语句；

例如：

public static int add(int a,intb){

int c = a+b;



return c;

}

其中static就是指该方法为静态方法；

静态方法：

异常（Exception）

异常：就是指当我们发生了一下例如：内存泄露，内存溢出，空指针，数组越界等编译器无法解析的错误时需要我们认为处理；

异常处理的语句如下：

try {

System.out.println("我是try");

//先走这里，如果没有异常发生则继续往下走

int a = 5/0;

System.out.println(a);



} catch (Exception e) {

//如果一旦发生异常就终止上面的语句，

//跳出try执行catch里的语句

System.out.println("我是一场");

}

代码
第一次的代码

package app1;

//导入一个系统包

import javax.swing.JFrame;



public class App extends JFrame {

/*

 * 构造方法

 */

public App() {

//定义窗口

this.setSize(640,700);

//禁止最大化

this.setResizable(false);

//设置标题

this.setTitle("飞机大战");

this.setLocation(100,100);

//设置点击关闭后并关闭后台

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//显示窗口

this.setVisible(true);

}

public static void main(String[] args) {

new App();

}