java基础知识起步

Posted 2020-07-28

第一章

将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单步跳入，跳入程序内部执行，如进入方法内部） 

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

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

for循环和foreach循环的区别：

1. for循环需要知道循环的次数，foreach不需要知道循环的次数
2. foreach用来遍历数组和集合使用更简单
3. foreach循环语法格式更简单，无需下标，没有赋值语句，没有循环条件，没有迭代语句，这些操作有系统来操作
4. foeach循环不要尝试去改变数组元素的值，因为数组元素赋给了一个临时变量

2.Return 语句的作用:

1.  结束当前方法的执行并退出
2. 返回调用该方法的语句出

第四章

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.成员变量和局部变量的区别：

1. 作用域不同
2. 初始值不同(对于成员变量如果在类定义中没有给它赋初值，Java会给她一个默认值，基本数据类型为0，引用数据类型为null，但是Java不会给局部变量赋值必须在定以后赋初值)
3. 在同一个方法中，不允许有同名的局部变量
4. 局部变量可以和成员变量同名，在使用中局部变量有更高的优先级

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

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

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

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

6.This关键字的用法：

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

Person(int age){this.age=age}

1. 使用this调用成员方法 this.work();
2. 使用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.封装的作用：

1. 避免外部操作引起的影响
2. 提高松耦合和代码重用性

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

8.包的作用：

   1.java 文件的组织形式

   2.管理java文件

   3.解决文件同名问题

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

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

9.访问修饰符

修饰符	同一类中	同一包中	子类中	任何地方
Private	Yes	No	No	No
无访问修饰符	Yes	Yes	No	No
Protected	Yes	Yes	Yes	No
Public	Yes	Yes	Yes	Yes

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

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

Public class Student{

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

}

 

第七章

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

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

2.继承的语法：

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

子类继承父类的什么：

1. 继承public 和protected修饰的属性和方法，不管子类和父类是否在同一个包里。
2. 继承默认权限修饰符修饰的属性和方法，但子类和父类必须在同一个包里

 

 

 

子类不能继承：

1. 无法继承private修饰的属性和方法
2. 无法继承父类的构造方法
3. 子类与父类不在同包使用默认访问修饰符修饰的(friendly)

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

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

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

1. 构成方法的重写的条件：

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

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

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

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

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

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

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

5.super关键字的使用：

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

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

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

  Super指代父类：

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

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

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

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

1. 继承条件下的构造方法的调用规则：
   1. 规则一：如果子类的构造方法中没有通过super显示调用父类有参的构造方法，也没有通过this显示调用自身其他构造方法，则系统会默认先调用父类的无参构造方法,在这种情况下，是否写 “ super(); “ 语句效果是一样的
   2. 规则二：如果子类的构造方法中通过super显示调用父类的有参构造方法，那将执行父类相应构造方法，而不执行父类无参构造方法
   3. 规则三：如果子类的构造方法中通过this显示调用自身的其他构造方法，在相应的构造方法中应用以上两条规则。
   4. 在继承条件下，代码的执行，先执行父类无参构造方法后调回子类，在一个类中，先加载父类属性，然后加载父类构造方法，然后子类属性，最后子类构造方法

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

1. Object的equals()方法

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

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

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

1. 一个类构造方法在如下两种情况中总会执行：
   1. 创建该类的对象(实例化)
   2. 创建该类的子类的对象(子类的实例化)

访问修饰符

8.类图：—sex：String

 

 

 

 

1. 多态

多态一词通常含义是指能够呈现出多种不同的形式或形态。他意味着一个特定类型的变量可以引用不同类型的对象，并且能自动地调用引用的对象的方法。

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

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

1. 将一个父类的引用指向一个子类对象，称为向上转换，自动进行类型转换
2. 此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法
3. 此时通过父类引用变量无法调用子类特有的方法

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

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

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

13.多态的优势：

1. 可替换性：多态对已存在的代码具有可替换行
2. 可扩充性：多态对代码具有可扩充性，增加新的子类不影响已存在的类的多态性，继承性，以及其他特性的运行和操作，实际上新加子类更容易获得多态功能。
3. 接口性：多态是父类向子类提供一个共同接口，由子类来完善或者覆盖来实现。
4. 灵活性：多态在应用中体现了灵活多样的操纵，提高了使用效率
5. 简化性：多态简化了对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。

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.抽象类

1. 抽象类不能被实例化
2. Abstract修饰符不能和final修饰符一起使用。
3. Abstract修饰的抽象方法没有方法体
4. Private关键字不能修饰抽象方法
5. Abstract关键字必须在访问修饰符和返回值类型之间
6. 一个类继承一个抽象类必须重写继承的所有抽象方法，除非它也是个抽象类

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修饰

规则：

1. 抽象类与接口不能实例化
2. 抽象类与接口分别被继承与实现的场合，其子类必须实现其中的抽象方法
3. 抽象类中的抽象方法的访问修饰符不能为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为异常类的父类，分为

1. Error是java虚拟机异常
2. 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 自定义异常类名(“异常原因”);