Java基础(二)

                                       Java基础(二)

1. while循环

while循环---线判断在执行

循环—就是重复发生的过程(循环一般有充分的前提条件)

语法：while（表达式）｛循环体｝循环体如果是true就执行循环，如果是flase就结束循环

do while循环---先执行在判断

语法：do｛循环体｝while（循环条件）

2. for循环

语法：for(表达式1，表达式2，表达式3){

       循环体

}

表达式1：计数器的初始化，他只执行一次

表达式2：循环条件的判断，他多次执行

表达式3：计数器的累加，多次执行

3. break和continue

break：跳出当前上层循环

continue：终止当前的本次循环，但是不会终止后续的循环

4.函数和数组

1.  函数(也叫方法)

是一段能完成独立功能的代码块，我们可以写一次方法，多次调用，提高了的代码的复用性

语法：

<public> <static> 返回值类型【void】方法名（【数据类型 变量名，数据类型1 变量名1，………】）{

//方法体

【return 结果值】；------返回值

}

返回值类型[void]：返回值类型就是函数执行后要给调用者的数据类型

就必须有return，如果是void就不用return

2.    方法调用的内存分析

3.    图解方法调用的内存分析

我们管主函数调用时所传递的变量a,b叫做实参，方法中的参数叫做形参，我们调用方法时是通过值传递的方式吧实参的值传给方法的形参

Java语言中只有值传递

传递参数时数据类型必须一致，在retuen后面的代码是无法访问的

2.数组的定义

引用数据类型都必须用new

       定义数组的语法

       语法：数据类型[ ] 数据名=new 数据类型[整数]

语法 数据定义[ ] 数组变量名=new数据类型[ ]{ 数组的值}

整数：指的是数组的长度

       栈：空间小，主要存储地址和基本类型的变量，存取速度快

       堆：空间大，主要存储引用类型的变量，存取速度慢

       我们操作数组是通过数组的下标老操作数组的

数组分配空间的图

       Int[] arr=new int[5];

      

数组的内存结构

1.    注意数组月结的问题

2.    数组在内存中的结构，在java中，内存被分为两种，一种是栈，一种是堆，

栈----容量小，存取速度快，适合存储生命周期短的数据，栈中存储变量，数据变量，

        特点---先进后出

堆----容量大，存取速度慢，适合存储生命周期长的数据，适合存储对象

        特点-----随便拿数据

3.  遍历数组

数组的遍历

求及值-----最大值

求及值-----最小值

4，冒泡排序

       冒泡排序的定义---相邻的两个数逐个的做比较，如果前一个数比较后一个数小那么就交换过来，当第一轮比较完毕后最小的值一定产生在末尾

       23，1，32，7，13进行冒泡排序

      

       冒泡排序的方法

      

5.二分法查找

前提条件----是对有序的数组进行查找,效率高

return  midindex;

数组的倒置

5.  二维数组

数组中还有数组就是,数组可以有n维

语法----数据类型 [ ] [ ] 数组名=new 数据类型[整数 ] [ ];

二维数组的长度第一维是必须指定长度的

5.方法的重载

重载(overload)的概念：在一个类中有两个或者两个以上同名的方法，但是方法的参数不同(指的是两个方法的参数的个数不同，还有就是方法的参数类型不同)，与返回值无关

方法的重载目的在于提高代码的可读性与节省命名的词

示例方法的重载，(里面有多层调用)----第二张图是简易写法

 

 

6. 面向对象-------真正的java语言

1.面向过程  c语言

分析解决问题的所需要的步骤,然后我们用函数一步一步的调用实现

2.面向对象(oop)-----面向对象编程

面向对象的思想就是抽取一类基友相同属性和行为的事务，在java中，万物皆对象，对象是一个具体的实物

3.类

我们把某些具有相同的属性和行为的四五抽象成一类

类 类似一个模版的东西，对象是根据这个模版产生的样本

类是一个概念，是抽象的

对象，是一个实物

类的语法

         Class 类名｛

         属性-----成员变量

         行为-----方法

｝

属性(成员变量)的定义

  数据类型  变量名=初始值（也可以不给初始值）

类是一个概念，不能直接使用，需要实例化这个类才可以用

根据类来实例化对象

语法  类名 (数据类型)  变量名=new类名()；

如何给一个具体你的对象来赋值---对象的变量.属性名=具体值

4.  匿名对象

匿名对象是没有意义的，实际开发中最好不要用匿名对象，

7. 封装

Private只能在本类中访问

封装的目的-------------提高数据的安全性，通过封装，可以实现对属性的访问权限控制，同时增加了程序的可维护性

将属性私有化，提供外部访问的公有化方法-----set赋值的方法和get外部访问的方法

This关键字------代表的是当前的

8. 构造器

构造器的方法作用就是给类的属性赋初始值，构造器的方法必须和类名一直，有无参数构造和有参数构造

9. static关键字修饰属性

语法：sttic 数据类型变量名；

使用tatic修饰符的修饰的属性我们认为是类的属性，不带static修饰的属性我们认为是对象的属性

类属性访问

       第一种方式：类名.属性名(推荐使用)

       第二种方式：对象实例.类属性

10.     static关键值修饰方法

语法：public static 返回值（void）方法名（数据类型1 变量1，数据类型2 变量2）｛

               方法体

               [return结果]

｝

Static修饰在方法上就是类方法

11.单例模式（singleton）--------设计模式

1.懒汉---在类加载的时间就创建了对象

构造器私有化

在类内部new自己本身(是私有的)

      

package webjavascript;   publicclass Singleton {   //在单例类内部创建自己本身的对象   privatestatic Singleton s=new Singleton();   //构造器的私有化   private Singleton(){        }   //获得单例的对象   publicstatic Singleton getSingleton(){      returns;   }   publicstaticvoid main(String[] args) {      //内存空间永远只有这一个对象      System.out.println(Singleton.getSingleton());   } }

 

2.饿汉模式-----在调用的时间在创建对象

package webjavascript; /**  * 单例模式饿汉  * @author Administrator  *  */ publicclass Singleton1 {   privatestatic Singleton1 s1;   private Singleton1(){        }   publicstatic Singleton1 getSingleton1(){      if(s1==null){        s1=new Singleton1();      }      returns1;   }   publicstaticvoid main(String[] args) {      System.out.println(Singleton1.getSingleton1());   } }

11.     类的继承

定义一个公共的类，这个类有其他类共有的属性行为和方法----我们就采用继承来减少代码的冗余

继承的语法----使用extendes关键字

class 子类    extendes 父类｛

        子类的属性

子类的方法

｝

继承的特点：子类会把父类所有的属性和方法继承下来

Note-----final修饰的类是不能被继承的

12.     supper

1.    子类实例化的过程中父类的构造器先被调用，然后字调用子类的构造器

2.    子类通过构造器实例化时要调用父类的默认构造器，是隐含了supper（）这个方法，但是如果子类的构造器中调用了父类的有参数的构造器，那么无惨的构造器就不会被调用了

3.    Supper的调用必须要放在方法的第一行

4.    Supper可以表示父类的引用，我们可以使用supper和this关键字来区分父类和子类中同名的属性，在子类中访问属性的查找顺序首先在子类中查找指定的属性的名字，如果在类中没有该属性，就会去父类中去找，

This关键字

代表当前类的指定示例的引用

可以区分同名的的属性和去不变量

通过this关键字可以调用同类中的构造器(this()，this（参数列表）)

调用本类里面的属性，this.属性名，this.方法()

super关键字用法

supper.xxxx-----代表的是调用父类的属性或者行为

方法重写(override)

在类中如果有一个方法和父类的方法名一样，就代表着重写了父类的方法，这样的话在使用这个类的时间就不会使用父类中的方法了

final的使用方法

final可以作用在属性，类，方法

如果final修饰类---代表类不能被继承

如果final修饰属性------属性的值不能被改变

如果final修饰方法------代表方法不能被重写

常量的定义

 

13.    抽象类----absract

抽象方法概念

当多个具体的实体类存在着共同的行为，但是有不同的表现，我们在父类继承过程找那个父类的犯法具体实现不同确定，但是能确定

抽象类语法

abstract class------抽象类

public abstract 方法名-----抽象方法

抽象类不能被实例化

在类继承了抽象类，必须实现父类的所有的抽象方法

抽象类可以继承抽象类，这样的话就可以不用实现父类的抽象方法

抽象类不能和其他关键字共存---static，final，private

14. 接口

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

语法

Interface 借口名｛

      方法的定义

｝

      在接口中定义的所有的变量都是常量,默认就是被final,static修饰的,值是不能被改变的(常量字母都要大写)

接口的继承和实现

接口也可以继承接口，接口1.7之后可以多继承，接口也可以多实现，如果实现了某一接口，就必须实现接口里面的方法

使用接口的好处

1.    接口的定义是一种标准，可以是我们的代码分层开发，分模块开发

2.    降低代码的耦合度，提高代码的可扩展性和可维护性

3.    接口改进了单继承的局限

接口和抽象类的区别

1.    接口的所有方法都是抽象的，抽象类里面的方法可以是抽象的，也可以不是抽象的

2.    接口和抽象类都不能被实例化，接口需要类来实现后实例化实现类，抽象类需要类来继承后实例化子类

3.    抽象类智能单继承，接口可以多继承和多实现

4.    接口中的属性是static，finall类型的，抽象类中的属性和普通的类没有什么区别

5.    接口中的方法默认就是抽象的，不需要加absract，抽象类中的方法需要加adsract关键字

类的单继承原理

类是不可以多继承的-------例如两个类中有两个完全相同的方法，子类会不知道用哪个方法，

如果是接口的话会把两个完全相同的方法合成一个方法-----这就是接口的多继承

15.多态

多态就是行为具有表现多种功能的能力

接口的多态—接口的多态基本上类的继承多态是一样的,不同的是类的继承使用的是继承关系实现多态,接口采用实现的方式实现多态

16.Math类

自然对数---Math.E

圆周率----Math.pi

绝对值-----Math.abs(-1.5)

把小数去掉整数加一----Math.ceil

……………………………………查看帮助文档

包的定义

包---就是文件夹

作用---对类做分类管理,可以区分同名不同类的包

语法----package 包名;(不同级别用.来风格)

Scanner扫描器

第一步—导入Scanner---import java.util.Scanner

第二步-----创建对象-----Scanner s=new Scanner(System.in);

第三步-----使用功能---调用Scanner类的方法,例如int next…….等待我们从键盘输入一个数值

17.内部类,权限修饰符

类内部的类就是内部类

把一个类定义到另一个类中,那么内部的类就是内部类

注意—内部类不能直接创建

创建内部类的语法----外部类.内部类 变量名=new 外部类对象.new内部类对象

例如----- Outi.iner neibu = new Outi().new iner();

内部类的外部类的方法如果想要访问内部类的方法,必须创建内部类的对象,根据内部类的对象来访问

私有内部类

静态内部类的创建语法----外部类.内部类 变量名=new 外部类名.内部类对象

匿名类----就是这个类没有名字

接口不能实例化,但是我们在创建匿名类的时间可以借助接口----例如 new 接口名(){ 实现接口的方法};大括号后面一定要加分号;

访问权限修饰符

	Private	默认	Protected	Public
类	N	Y	N	Y
方法	Y	Y	Y	Y
属性	Y	Y	Y	Y

四种访问权限修饰符的作用范围

在类上的权限修饰符都是public的，方法大多还public的（使用一些设计迷失可能会使用protected获得private），属性绝大多数都是private

访问权限修饰符对方法和属性的访问限制

	同类中	同一个包，没父子类关系	不同的包有父子类关系	不同包也没有父子关系
Private
默认
Protected
Public

18.object类

Object类是所有类的根类，所有的类都是直接或者间接的去继承object类

类object是类层次结构的根类，每个类都使用object作为超类，所有的对象，包括数组都实现这个类的方法

19.eclipse源码查看和outline视窗

查看源码

关联源代码

      当看不到源代码的时间-----点击Attach Source---选择压缩包形式的----选择jdk源码路径src.zip----点击ok

20.异常的分类和处理

编译时异常和运行时异常

在我们写程序的的时间难免会出现错误，java中的异常机制为了提高我们程序的健壮性和容村性二存在

Throwable类是java语言中所有错误或异常的超类

throwable类是所有异常的超类

      Exception类是编译时异常

runtimeException类是运行时异常

运行期异常的处理--------自行解决和抛出去

类型转换异常

      数学异常

      数组越界异常

      类型转换异常

      空指针异常

      传递非法参数异常

异常中的finally-----

      try｛｝finally｛这里面的代码无论如何都会被执行｝finally主要用于异常发生时释放资源

final，finally，finalize的区别

      1.final可以修饰类，方法，如果在类上，类不能被继承，如果在方法上，方法不能被重写，如果修饰属性，值不能被改变

      2.finally是和try，catch异常处理模块一起用的语句块，他在最后一定会被执行

      3.finalize当堆中的对象没有任何引用是这个方法会被调用来做垃圾回收

编译期异常处理

      自己处理和向上抛出

运行时异常要向上抛出

自定义异常

      我们自己定义的异常都是运行时异常------继承runtimeException类,继承runtimeException构造器

      自定义异常语法----------throw new 继承了runtimeException的类(“写上异常”)

21.字符串

数据类型----基本数据类型和引用数据类型(引用数据类型有类，接口，数组)

字符串是引用数据类型（存储在推中）

String类代表字符串----String类不能被继承

      String str="abc"；----------定义一个字符串变量

      str存储在栈中

      abc存储在数据共享区

      字符串的值是不能改变的

String str="helloword";和String str1 = new String("helloword");的区别

      Stringstr="helloword"---------- str存储在栈中，helloword存储在数据共享区（静态区）

      Stringstr1 = new String("helloword")---------new String在堆中，str1在栈中，helloword在数据共享区（静态区）