java学习指南

JAVA入门

##面向对象

• 完全基于类、对象、接口
• 以类的形式组织代码和数据类型
• 程序的执行入口“main()方法”必须出现在某一个类中
• 封装、继承、多态
• 去掉了全局函数和全局变量

##简单

• 摒弃了C++中容易引发程序错误的一些特性，如指针、结构、多重继承等
• 提供了丰富的类库（API）
• Java语言提供内存自动回收机制（不需要delete）
• Java语言中没有指针的概念，引入了引用
• Java无需分离头文件和源文件

##平台无关

一次编译，到处运行！

多线程

• 同时完成多个任务

动态

• 动态维护程序及类库

#基本数据类型和数组

数据类型

类型转换

• 低精度->高精度，系统自动完成
• 高精度->低精度，必须使用类型转换运算

eg：int x=(int)34.89

输入、输出

输入基本型数据

• Scanner：是一个类，可以使用该类创建一个对象（使用时需要import java.util.Scanner）

  Scanner reader = new Scanner(System.in);

  • reader对象可以调用下列方法，读取用户输入的各种基本类型数据，

    nextBoolean(),nextByte(),nextShort(),nextInt(),nextLong(),nextFloat,nextDouble()

    • “123 456 789”，每个数字之间用空格（一个或多个空格）隔开，可被多个nextInt()读取，空格及回车不会被读取。（注：输入数字中不能夹杂除数字、空格、回车之外的其他字符，否则会报错）

###输出的基本型数据

• System.out.println() 换行输出，参数为输出的内容

• System.out.print() 不换行输出

• 允许使用+将变量、表达式等并置一起输出

##数组

###数组声明

1. [] 属于类型的一部分。应该写在变量前面。如：

    int [] numbers1,numbers2; 
    int [] [] array;//二维数组
    int numbers []; // 不建议
   

2. java不允许在声明时制定元素个数：

   int [10] a; int a[10]; 错误

数组创建

int [][] a1 = new int[4][5]; // 元素初始值为 0
int [] b = {1,1,1,1,1,1}; // 静态初始化
int [][]a1 = new int[4][]; /　/ 只声明第一维大小
a1[0] = b;
a1[1] = new int[5];
a1[2] = {1,2,3}; //错误，只允许在初始化时使用
int size = 6;
a1[2] = new int[size];
System.out.println(a1.length); // length 属性是元素个数
System.out.println(a1[0]);//输出a1[0]存的值
System.out.println(""+a1[3]);//输出a1[]

for语句的改进方式

for(int i:a)//for(数组数据类型 循环变量ch :数组名c)
{
    System.out.println(i);
}
循环变量i依次取数组a中的每一个元素

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YGg58rAn-1677901659245)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\image-20230222210839535.png)]

类与对象

构造方法

• 构造方法是一种方法，名字必须与类名相同，没有返回值类型。
• 构造方法可以重载
• 如果类中定义了一个或多个构造方法，java将不提默认构造方法
• 空对象不能调用
• 数组中的每一个对象需要单独实例化，否则为初始值 null

Java程序结构

• 如果一个源文件（.java)中有多个类，最多只能有一个 public 类
• 源文件的命名必须和含有“public” 声明的类名相同，并且区分大小写
• 主类：含有 public static void main()方法的类
• 一个应用程序必须有一个主类
• 源文件中每个类都会被编译成一个和类名对应的 class 文件

参数传值

• 基本类型参数传值：传递实参值的拷贝，而不是实参本身
• 引用类型参数传值：也称为传地址。方法调用时，实际参数的引用(地址，而不是参数的值)被传递给方法中相对应的形式参数，函数接收的是原始值的内存地址；在方法执行中，形参和实参内容相同，指向同一块内存地址，方法执行中对引用的操作将会影响到实际对象。

public class Point{
    int x,y
        Point(int x,int y)
    {
        this.x=x;
        this.y=y;
    }
}
Point a= new Point(1,2);
创建对象a时，Point类中的成员变量x,y被分配内存空间，并返回一个引用（相当于内存地址）给a

实例与类

实例成员和类成员

class Student{
 int age; // 实例成员变量
 String name; // 每个对象独有
 static Teacher teacher; // 类成员变量
 // 所有对象共享
 // 类方法
 static void changeTeacher(Teacher t){
 teacher = t;
 } 
}

• 对象的实例变量为对象所有

• 对象的类成员被所有对象共享

• 可以通过类名访问类成员，也可以通过对象访问类成员

• 类的字节码文件被加载到内存，如果该类没有创建对象，类中的实例变量不会被分配内存，但是类变量在该类被加载到内存时，会被分配相应的内存空间。

实例方法和类方法

区别 1：

• 对象创建后才分配实例方法入口

• 对象创建前已经分配类方法入口，无对象情况下，可通过类名调用

区别 2：

• 所有对象都不存在时，实例方法的入口地址撤销

• 程序退出时，类方法的入口地址才被取消

• 实例方法不仅可以操作实例变量还可以操作类变量

• 类方法仅能调用其它类成员，不能以任何形式引用 this、super，不能访问实例成员，因为实例成员还未被加载到内存

方法重载

和C++一致

this指针关键字

• 和c++类似，this在Java中表示某个对象
• this不能出现在类方法中

包（package）

• 合理组织 Java 项目，将功能近似或联系密切的类放在一个包内

• 无包名的类只能在当前包使用；

• 有包名的类需要注明为 public 类，可以被其它包的类使用

import语句

• 用于引入库中的类或自己定义包中的类

  import java.util.Scanner

访问权限

• 私有变量和私有方法(private)只允许在自己类中调用

• 共有变量和共有方法(public)：可以在任何类中被使用,包括import导入

• 友好变量和友好方法(无关键字，默认)：只允许在同一个包内被调用，import导入不可用

• 友好变量和友好方法(protected)：protected 只有自己和子类可以new

• 类对象成员的可见性

访问权限	同类	同包	不同包
private	可以	不可以	不可以
友好的	可以	可以	不可以
protected	可以	可以	不可以
public	可以	可以	可以

对象数组

声明完对象数组，一定要为数组分配对象

Student []stu;//声明一个一维数组stu
stu = new student[10]; //分配
stu[0]=new Student();

子类和继承

1. 语法：Java 的类不允许多重继承，继承关键字：extends

class People{
 String name; // 一般属性
}
class Student extends People{
 String studentNumber; // 特殊属性
}

2. 继承权限：

3. 子类对象构造过程：

   1、调用基类构造方法，如果没有指定，默认调用无参构造方法；

   2、按声明顺序调用成员的初始化方法；

   3、调用自身的构造方法。

成员变量隐藏

1. 子类中声明的成员变量和父类的成员变量同名(声明类型可以不同），则子类就隐藏了这个继承的成员变量
2. 子类继承的方法只能操作子类继承和隐藏的成员变量
3. 子类新定义的方法可以操作子类继承和新声明的成员变量
4. 子类新定义的方法不可以操作子类隐藏的成员变量

方法重写

1.能被继承的实例方法都可以重写，从而具有新的功能

2.重写的方法会隐藏被继承的父类方法

3.重写必须保持方法名、参数个数、参数类型与父类方法一致。返回值类型与父类方法保持一致或是子类型

4.重写父类的方法时，不可以降低方法的访问权限，可以保持相同或提高

super

1. 子类访问被继承或隐藏的成员变量：super.成员变量

2. 子类访问被继承或隐藏的父类方法：super.方法()。该方法中的成员变量来自于父类

3. 子类构造函数无参数时默认省略

4. 有参数时，不可以省略

final

1. final class A {} : A 不能被继承

2. final 类型 方法名():不允许子类重写

3. 修饰常量，声明时必须赋值，不可以再被修改。

   final 类型 变量名 = 常量值;

​ final 类型 变量名 = new 类型();

上转型对象

• 将子类对象的引用赋值给父类变量

• 上转型对象实体由子类创建。只能访问父类声明过的成员。

• 变量：被==继承的或者被隐藏==的；

• 方法：被==继承的或者重写==的

abstract类和abract方法

abstract class A{
} //抽象类
abstract int fouction(); //抽象方法

1. abstract 方法只允许声明，不允许实现，不允许final(不允许被继承)、static同时修饰

2. 父类方法只用于提供行为标准（方法名、参数类型等），子类遵守标准实现。

3. abstract 类中可以有abstract 方法，也可以没有abstract方法，抽象类中可以有抽象方法，有抽象方法必须是抽象类

4. 抽象类不能实例化对象(new)，但可以有构造方法

5. 抽象类的非 abstract 子类必须实现所有抽象方法

6. abstract类可以作为上转型对象

接口与实现

接口

1. 接口关键字 interface，声明一个接口和声明一个类一样
2. 不声明 public 的接口是友好接口，只可以在当前包使用
   • 属性：接口中只允许出现常量。默认 public static final
   • 接口中只允许出现抽象方法。默认 public abstract

public interface Printable{
    public static final int MAX=100;
    //等价写法 int MAX =100;
    public abstract void();
    //等价: void add();
}

3. 接口可以单继承，也可以多继承，但只能继承接口

4. 类实现接口使用关键字 implements

• 非抽象类必须重写接口中的所有抽象方法，并且该方法必须限制为 public 权限

• 父类实现了某个接口，则子类会默认实现该接口

• 一个类可以实现多个接口

• 抽象类实现接口，不需要重写所有的抽象方法。

5. 接口回调

6. 接口参数

7. 抽象类和接口的异同

内部类与异常类

内部类

普通内部类

1. 外部类可以通过内部类对象访问内部类的成员，而不能直接访问
2. 内部类的方法可以直接访问外部类的成员
3. 内部类可以独立继承其它类，或者实现接口
4. 非静态内部类不可以拥有静态成员

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aADsLtpe-1677901659246)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\image-20221201150542447.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OPGu97IZ-1677901659246)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\image-20221201150624093.png)]

静态内部类

1. 静态内部类是外部类的静态成员，静态内部类附属于外部类而不是外部类对象
2. 外部类访问静态内部类实例成员必须通过静态内部类实例
3. 静态内部类的（实例/类）成员不可以访问外部类的实例成员，类似于静态方法不可以访问实例成员

局部内部类

1. 定义在方法内部，拥有作用域。

2. 不存在外部可见性，因此没有访问修饰符，包括public,protected,private,static。

3. 局部内部类的方法可以访问外部类的静态和实例成员。

4. 局部内部类访问所在方法的局部变量时，该变量不可被修改。

匿名类

1. 临时创建一个子类对象时使用。所以只需要知道父类的名称，不需要知道子类的名称。所创建的对象便是匿名类对象。
2. 前提：已经有一个父类或一个接口

与父类相关

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kZOd2dre-1677901659246)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\image-20221201231153183.png)]

改写为匿名类则为：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dUhKrE6f-1677901659247)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\image-20221201231205142.png)]

与接口相关

interface Person {
 public abstract void eat();
 public abstract void run();
}
public class Demo {
 public static void main(String[] args) {
 Person p = new Person() {
public void eat() {
 System.out.println("child eat");
 }
 public void run(){
System.out.println("child run");
 }
 }; // ;代表实例化语句的结束
 p.eat();
 p.run();
 }
}

异常类