java 基础

第一章

将java文件编译成class文件: 

在记事本中编辑java代码-----修改文件名为.java文件----打开cmd---进入文件所在文件路径如f:----在命令窗口执行

javac 文件名.java--执行命令：java 文件名

  包名小写，类名首字母大写，类名可.java文件名要完全一致，是\n注意不是/

用javac 文件.java命令编译，后用java  类名 执行形成的Class文件

第二章

标识符的命名规则：(驼峰命名法)变量名，方法名第一个单词小写后面每一个单词首字母大写

三种注释：单行，多行《按住Shift鼠标点击开始结束部分，Ctrl+Shift+/》，文本注释

   扫描类库:Scnner input=new Scanner(system.in);

   取得输入的内容: answer= input.next();

   Boolean flag= Input.hasNextInt();判断输入的值是不是整数,是就返回true,否则false

知道8种基本数据类型(byte,short,int ,long,float,double,char(a=97,A=65),boolean)存在栈中

       引用数据类型：数组，类，接口（存在堆中）

Byteàshortàintàlong àfloatàdouble

       char

Char可以自动转换为int类型 存储位数越多，类型的级别就越高

/*int age1=19;

    char sex='女';

    int result=age1+sex;          //注意int和char类型相加自动转为高级的int类型，结果为int类型

  System.out.println(result);*/

关系运算符的关系表达式结果为 布尔值

逻辑运算符与&，|，!

优先级：! > & > ^ > | > && >||(短路&&如果前面一个不成立后面的不参加运算)

Null值不能用equals方法判断等值;

三元表达式： 条件？表达式1 ：表达式2(条件为真执行表达式1,条件为假执行表达2)

Short s=1 ,s2=4; short s5=s+s2;两个short类型变量可以相加)（s=s+8;这时候报错）

String .equals比较的是值(不能为null)，==比较字符串的地址

第三章

1.Switch:(转换)

Switch(int mingci){          //快捷键 Alt+/+回车

Case 1 :System.out.print(“参加麻省理工一个月的夏令营”) break;

Case 2 :system.out.print(“送笔记本”)    break;          //跳出所在的循环

                                     Continue    //继续下一次循环

Default :   只有所有的case没有匹配上才执行default内容

}

Switch中的判断，jdk1.7一下不能为字符串,可以是int，enum,char(可自动转换为int)

While(条件){循环体} 当条件成立时执行，直道条件为false

注意：do...while();  结束后面有分号

For(int i=0;i<10;i++){循环体;}

程序调试问题：

   1.双击添加断点--à 2.按住小虫子或F12启动调试---à3.F6单步调试（F5单步跳入，跳入程序内部执行，如进入方法内部） 

   java中的增强foreach循环（for score:scores）{system.out.print(score);}

for(int I : scores){system.out.print(i)}

for循环和foreach循环的区别：

for循环需要知道循环的次数，foreach不需要知道循环的次数

foreach用来遍历数组和集合使用更简单

foreach循环语法格式更简单，无需下标，没有赋值语句，没有循环条件，没有迭代语句，这些操作有系统来操作

foeach循环不要尝试去改变数组元素的值，因为数组元素赋给了一个临时变量

2.Return 语句的作用:

 结束当前方法的执行并退出

返回调用该方法的语句出

第四章

1．数组在内存中是连续开辟空间的(数组中存放的元素可以是基本数据类型也可以是引用基本数据类型，必须是同一数据类型)

(1)  int scores[]={1,2,3,4}; 或 int[] scores={1,2,3,4};

       Int[] a={3,5}     定义数组时不指定长度，

  (2)  Int[] a=new int[]{1,2,3};   初始化数组时，不指定长度

  (3)  Int[] a; a=new int[5]; a[1]={2};

数组是一个变量，存储相同数据类型的一组数据

数组的下标从0开始；

数组的编译错误和运行时异常；

2.二维数组的使用

二维数组的定义和初始化：

   Int[][] scores=new int[5][5];

   Int[][] scores={};

   Int[][] scores=new int[][]{{1,2}  ,{1,3},{3,4,4} };

Arrays类极其常用的方法：.equals(array1,array2);比较两个数组是否相等

  .sort(array);数组的升序排列

  .toString();array 将数组的Array转换成一个字符串

  .fill(array,val);把 数组array的所有元素都赋值为val;  

  .copyOf(array,length);将数组array复制成一个长度为length的新数组

  .binarySearch(array,val) 查询元素val在数组array中的下标 

3.数组中的数据类型是必须“统一”自动转换为同一种数据类型

 Int[] array={2,4,’a’}

第六章

1.面向对象

类和对象的关系：就是抽象和具体的关系

类名必须大写

成员变量有默认初始值；

OOA 面向对象分析    OOD面向对象分析

2.面向对象的优点：

   1.与人类的思维习惯一致，

   2.信息隐藏，提高的程序的可维护性和安全性

   3.提高了程序的可重用性

类成员主要包括两部分：成员变量和成员方法

3.方法重载的优点：可以根据参数的不同，采用不同的实现方法，而且不需要编写多个名称，只要记住一个方法名即可

重载条件：方法名相同，参数列表不同(参数个数和参数类型不同，

参数的类型和个数相同，顺序不同)

4.成员变量和局部变量的区别：

作用域不同

初始值不同(对于成员变量如果在类定义中没有给它赋初值，Java会给她一个默认值，基本数据类型为0，引用数据类型为null，但是Java不会给局部变量赋值必须在定以后赋初值)

在同一个方法中，不允许有同名的局部变量

局部变量可以和成员变量同名，在使用中局部变量有更高的优先级

5.构造方法：

如果自定义了一个或多个构造方法，那么java不会自动添加默认构造方法

1.构造方法必须和类名相同

2.没有任何的返回值类型

3.用来创建对象，初始化数据

6.This关键字的用法：

使用this调用成员变量，解决成员变量和局部变量的同名冲突

       Person(int age){

                  this.age=age

       }

使用this调用成员方法 this.work();

使用this调用重载的构造方法，只能在构造方法中使用，且必须是构造方法第一条语句

Public penguin(String name,String sex){this.name=name;this.sex=sex;}

   Public penguin(String name,int health,int love,String sex)

  {this(name,sex); this.health=health;this.love=love;}  

This只能调用成员属性，实例方法，构造方法，不能调用类变量和类方法，也不能调用局部变量

this能不能调用类方法和类变量：

this可以调用类变量，但是类方法需要通过 类名.类方法 的形式调用。this是一个指向当前对象的指针，而对象是类的一个实例，所以this指向的是某个类的一个当前实例，而不是类本身

7.封装的作用：

避免外部操作引起的影响

提高松耦合和代码重用性

封装的概念：将属性私有化，提供公共方法来访问私有属性。

8.包的作用：

   1.java 文件的组织形式

   2.管理java文件

   3.解决文件同名问题

   4.也是一种访问控制机制

Java.lang包下面的所用工具不需要导入，可以直接引用

9.访问修饰符

修饰符

同一类中

同一包中

子类中

任何地方

Private

Yes

No

无访问修饰符

Protected

Public

10.在类中声明成员变量：

  成员变量可以是Class类型的成员变量

Public class Student{

  Private Person person;  //类中定义引用数据类型的成员变量

第七章

1.继承：使得一个类A能够直接使用另一个类B的属性和方法的途径

        类A可以有自己的属性和方法

2.继承的语法：

   修饰符 class 子类 extends 父类｛  //类定义部分｝

子类继承父类的什么：

继承public 和protected修饰的属性和方法，不管子类和父类是否在同一个包里。

继承默认权限修饰符修饰的属性和方法，但子类和父类必须在同一个包里

子类不能继承的－－－－－－：

无法继承private修饰的属性和方法

无法继承父类的构造方法

子类与父类不在同包使用默认 访问修饰符 修饰的(friendly)

如果从父类继承的方法不能满足子类的需求，在子类中可以对父类的同名方法进行重写。

方法的重写或方法的覆盖(  overriding )

                子类中根据需求对父类继承的方法进行重新编写

构成方法的重写的条件：

1.必须具有相同的方法名

2.必须具有相同的参数列表

3.返回值类型必须相同或者是其子类

4.不能缩小被重写方法的访问权限

重载(overloading)和重写(overriding)有什么区别：

  重载涉及  同一个类中  的 同名方法，参数列表不同，与返回值类型无关

  重写       是子类和父类之间的同名方法，参数列表相同，返回值类型相同或者是其子类

5.super关键字的使用：

  Super代表当前对象的直接父类对象的默认引用

  Super必须是出现在子类（子类的一般方法[super.方法名]和构造方法中）而不是其他位置。

Super 和 this 不能同时出现在一个构造方法中

  Super指代父类：

调用父类成员：成员变量，成员方法，通过super.XXX

2.调用父类构造方法，通过super(),必须出现在构造方法的第一句话

用于访问父类的成员，例如父类的属性，方法，构造方法

访问权限的限制，例如无法通过super访问private成员。

继承条件下的构造方法的调用规则：

规则一：如果子类的构造方法中没有通过super显示调用父类有参的构造方法，也没有通过this显示调用自身其他构造方法，则系统会默认先调用父类的无参构造方法,在这种情况下，是否写 “ super(); “ 语句效果是一样的

规则二：如果子类的构造方法中通过super显示调用父类的有参构造方法，那将执行父类相应构造方法，而不执行父类无参构造方法

规则三：如果子类的构造方法中通过this显示调用自身的其他构造方法，在相应的构造方法中应用以上两条规则。

在继承条件下，代码的执行，先执行父类无参构造方法后调回子类，在一个类中，先加载父类属性，然后加载父类构造方法，然后子类属性，最后子类构造方法

构造方法不能循环嵌套调用

Object的equals()方法

相等的属性值：两个对象具有相同的类型，相同的属性

同一个引用对象：两个引用指向同一个对象，即指向同一个地址

注意：如果单纯的使用object类的equals()方法来比较对象是否同一个引用对象，那么是跟操作符“==”没有区别

一个类构造方法在如下两种情况中总会执行：

创建该类的对象(实例化)

创建该类的子类的对象(子类的实例化)

访问修饰符

8.类图：—sex：String

多态

多态一词通常含义是指

能够呈现出多种不同的形式或形态。

他意味着一个特定类型的变量可以引用不同类型的对象，并且能自动地调用引用的对象的方法。

方法的重写是实现多态的基础。

10.子类转换为父类时的规则：

将一个父类的引用指向一个子类对象，称为向上转换，自动进行类型转换

此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法

此时通过父类引用变量无法调用子类特有的方法

11.向下转型的要求对接口和抽象（普通）父类同样使用

12.Instanceof  实现（boolean flag=pet instanceof Dog）

使用instanceof时，对象的类型必须和instanceof后面的参数所指定大类在继承上下级关系，否则会出现编译错误

13.多态的优势：

可替换性：多态对已存在的代码具有可替换行

可扩充性：多态对代码具有可扩充性，增加新的子类不影响已存在的类的多态性，继承性，以及其他特性的运行和操作，实际上新加子类更容易获得多态功能。

接口性：多态是父类向子类提供一个共同接口，由子类来完善或者覆盖来实现。

灵活性：多态在应用中体现了灵活多样的操纵，提高了使用效率

简化性：多态简化了对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。

14.final 修饰类、修饰方法、修饰属性

修饰类，不能再被继承

修饰方法，不能被子类重写

修饰的变量将变成常量，只能在初始化时 赋值 (单词每个字母大写)

15.static 的使用

修饰属性：调用用 类名 . 属性名

Static方法中不能使用非static属性;

修饰的静态代码块：

1.静态代码库比构造方法先执行，执行顺序是先加载父类中的静态代码块-后加载子类中的静态代码块，然后执行父类构造方法后执行子类中的构造方法

2.在类中的静态代码块无论创建多少个对象，只第一次创建时运行static代码快

3.当主函数中调用类中的静态方法也会先执行类中的静态代码库

4.在创建对象时候，会执行静态代码库

16.多态的使用：

1.父类指向子类对象

2.作为方法的形参

3.作为方法的返回值

18.return 返回多种不同类型的变量，多种不确定类型的可变参数的使用

   1.可以定义返回一个Object[] 类型的参数

   2.可以定义一个类，类中的属性定义为不同类型的属性，将不同类型的赋值给属性

public class Master {

    public void feed(Pet pet){

       if (pet instanceof Dog) {

           System.out.println("*********8");

       }

    }

    public void methad(int[] a){

    public void methad1(int...is){

    public void methad2(String s,int...is){

    public void methad3(Object...objects){

    public void methad4(Object[] a){

    public Pet getPet(int money){

       Pet pet=null;

       if (money>10) {

           pet=new Dog();

       }else if (money>5) {

           pet=new Penguin();

       return pet;

第8章

1.抽象类

抽象类不能被实例化

Abstract修饰符不能和final修饰符一起使用。

Abstract修饰的抽象方法没有方法体

Private关键字不能修饰抽象方法

Abstract关键字必须在访问修饰符和返回值类型之间

一个类继承一个抽象类必须重写继承的所有抽象方法，除非它也是个抽象类

2.抽象类和接口

1. 区别：普通方法必须有方法体，抽象方法不能有方法体，抽象方法要有abstract修饰。

2.抽象 类不能创建对象，普通类可以创建对象

3.抽象类是一个不能被实例化的类，它可以具有抽象方法或普通方法

4.抽象类便于复用，接口便于代码维护

 5.Public abstract class Person(){   抽象方法，或者  普通方法}

3.接口：是一个不能实例化，且只能有抽象方法的类型

1.使用interface关键字接口中只能有抽象方法

2.Public interface Person(){  抽象方法  }

3.接口中定义的变量默认是公共的 (public) 静态的 (static) 最终 ( final)  的常量（必须赋初始值）

   4.接口中定义的方法默认是公有 (public ) 的抽象 (abstract) 方法

   5.接口中方法必须有返回值类型

   6.接口static 不能修饰接口中的方法

   7.接口中不能用final 修饰方法

   8.接口中不能有构造方法

   9．接口可以继承多个接口，但是接口不能继承类

接口是针对行为而言的

多用组合少用继承

针对接口编程，不依赖具体实现

针对扩展开放，针对改变关闭

4.为什么接口中的方法不用abstract修饰呢，因为接口中只能有抽象方法不必用abstract修饰

规则：

抽象类与接口不能实例化

抽象类与接口分别被继承与实现的场合，其子类必须实现其中的抽象方法

抽象类中的抽象方法的访问修饰符不能为private，抽象类中的普通方法的访问修饰符可以为private,接口中的抽象方法的访问修饰符必须为public

5.implement 实现接口

   1.实现接口必须实现接口里面的所有抽象方法

   2.一个类同时继承一个父类，extends 在前，implements在后中间通过逗号，分开必须实现里面的所有方法

   3.接口中的继承，用extends关键字，接口可以继承多个接口，被继承的多个接口间用逗号分开

6. 一个子类继承一个父类和实现多个接口时：

1. 调用父类中的字段和方法使用super.XXX

2调用接口中的字段和方法用：在子类中定义一个接口类型的成员变量，用接口类型的变量去点接口中的字段和方法

7.匿名内部类：

   匿名内部类是指，父类是一个抽象类，在Test内的main方法中创建父类类型的对象，并在重写父类中所有抽象方法，

  在父类中的写法  Cook cook=new Cook(){  在这里重写父类中的抽象方法，也可以添加自己的方法，见BOOK1selfStudy-oop-Test3}  ;  后面有分号

8.内部类见   BOOK1selfStudy-oop-Test2}

  在内部类中调用外部类的属性用 外部类名Kitchen.this.XXXX的方法

抽象类中可以有构造方法，

第9章

1.异常的分类：

   Object 为异常的根类，其次是Throwable为异常类的父类，分为

Error是java虚拟机异常

Exception异常类，异常类分为SQLExcepton和RunTimeException等

2.常见的异常：

   1.ArithmeticException 计算异常

   2.ArrayIndexOutOfBoundsException 数组越界异常

   3.NullPointException 空指针异常

   4.ClassNotFoundException没有找到相应的类文件（可能没有导入相应的jar包）

   5.NumberFormatException 数据格式化异常（将不是数字转为数字格式的异常）

   6.inputMismatchException 数组数据不匹配异常(用户输入的类型和数据中类型不匹配)

   7.IllegalArgumentException 方法接收到非法参数

   8.ClassCastException  对象强制类型转换出错

3.try {}catch(){  要捕获的异常要和要发生的异常要 匹配}

4.try {} --catch (){}--finally{} 语句结构

1.如果try或catch 中有return语句，那么程序会先执行finally语句中的代码，执行完成或才执行return语句，如果finally中有ruturn语句就不会执行try {  }catch{ }语句中的return了

2.在try—catch—finally语句结构中，try语句块是必须存在的，catch和finally语句块是可选的，但两者至少出现其中之一。

5.终止程序的退出使用，system.exit(0);正常退出

                     System.exit(-1);非零数字是非正常退出

6.java中异常处理是通过5个关键字来实现 

try

catch  捕获异常

finally  无论是否发生异常，finally语句块中的代码总是执行，除非一种情况就是在异常处理代码快中执行System.exit(1)退出java虚拟机

throw 

throws

         Throws 声明方法可能要抛出的各种异常，

throw 手动抛出异常

e.printStackTrace();//打印堆栈异常信息

7.throw和throws的区别：

  1.作用不同:throw用于程序员自行产生并抛出异常，throws用与声明该方法内抛出了异常

  2.使用的位置不同，throw位于方法体内部，可以作为单独语句使用；thorws必须跟在方法参数列表的后面，不能单独使用。

  3.内容不同，throw抛出一个异常对象，且只能是一个；throws后面跟一个异常类型，且可以跟多个异常类。

8.自定义异常:  throw new 自定义异常类名(“异常原因”);