Java基础语法

cookieeee_

墨衍会员 · AI 创作全网分发码龄4年

关注

原创 2024-07-24 12:05:44 472 阅读 AI 写同款· GEO 优化 ›

Java 基础语法一个 Java 程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。下面简要介绍下类、对象、方法和实例变量的概念。阅读详情

第一章认识Java语言

1.1发展历程

Java的两种机制：Java虚拟机制和垃圾收集机制
Java语言的特点：简单性、面向对象、分布式、编译和解释性、稳健性和安全性、平台独立与可移植性、多线程
Java是Sun公司于1995年推出的
JavaEE是企业版、JavaSE是标准版、JavaME是嵌入式开发

1.2Java语言的特点

简单性
面向对象
分布式
编译和解释性
稳健性和安全性：首先需要编译器转换成一种称为字节码的“中间代码”，这个字节码文件在Java虚拟机上(JVM)上解释运行，也是平台独立的主要原因
平台独立与可移植性
多线程

1.3Java开发环境的搭建

Java变成经常使用如下工具：

Javac.exe，称为Java编译器，对Java源文件进行编译，生成跨平台的字节码文件 Java.exe，称为Java解释器，调用JVM解释、执行字节码文件，运行Java应用程序

源文件扩展名必须为.java，字节码文件扩展名为.class
编译生成的字节码文件个数和源文件中class的个数一致
Java源文件的文件名必须与其内包含的公共类类名相同

第二章基础知识

2.1关键字

访问控制：

public：声明公共成员，可以被任何其他类访问。
private：声明私有成员，只能在声明它的类内部访问。
protected：声明受保护的成员，可以被同一包中的类或者子类访问。

类、接口和包：

class：声明一个类。
interface：声明一个接口。
package：声明类所驻留的包。
import：导入包或类，使它们在当前Java源文件中可见。

方法修饰符：

void：表示方法没有返回值。
static：表示方法或变量属于类而不是类的实例。
final：表示方法或变量不能被重写或修改。
abstract：用于声明抽象类或抽象方法，必须被子类实现。

变量修饰符：

final：表示变量是常量，其值不能被修改。
transient：表示变量不参与序列化过程。

控制流程：

if、else、switch：条件语句，根据条件执行不同代码块。
for、while、do-while：循环语句，重复执行代码块。
break：跳出当前循环或switch语句。
continue：跳过当前循环的剩余部分并进入下一次循环。
return：从方法中返回并传递一个值（如果方法具有返回值类型）。

异常处理：

try：尝试执行代码块，如果发生异常则进行捕获。
catch：捕获try块中抛出的异常并进行处理。
finally：无论try-catch块是否抛出异常，finally块中的代码都会执行。
throw：抛出一个异常对象。
throws：声明一个方法可能抛出的异常。

其他：

instanceof：判断对象是否属于某个类或接口的实例。
new：用于创建新的对象实例。
extends：用于子类继承父类。
implements：用于实现接口。
assert：用于断言表达式的值是否为真，通常用于调试。

2.1标识符

标识符是标识不同Java程序元素的符号，包括变量(类)、接口

1.规则

首字符为_、$、英文大小写字母或中文
数字不可以放在第一位
不可以是关键字
长度没有限制
关键字虽然符合规则，但已被预定了，不能使用

2.2变量常量

在方法中定义的变量叫局部变量，必须初始化，且只在方法内有效

自动转换：用常数对整型变量赋值，不超过范围不用强转

2.3数据类型

引用类型也叫类类型
规则：低精度到高精度自动转换；高精度到低精度需要强制转换（=右为低精度）
3.13无特殊说明是double；3.13f或3.13F是float；3.13d或3.13D是double
Java中字符和整数本质相同，二者可以互相运算
byte或short数据类型在参与表达式运算前，会自动转换为int类型在书p32特殊细节
用常数对整型变量赋值 byte k=10，不超过该范围不用强转，不考虑类型高低问题

字符类型

Java中的字符和整数本质相同，二者可以相互运算，char t=97--->char t='a'
字符类型可以表示汉字
\u 表示一个 Unicode 字符字面量，它后面跟着的四个十六进制数字（0-9 和 A-F）指定了该字符的 Unicode 码点。

强制转换

byte或short数据类型在参与表达式运算前，会自动转换为int类型
数值表示范围，具有首尾相接特性

2.4运算符与表达式

逻辑运算：&&（全真为真）||（一真为真）
位运算：&（位与）：等同于逻辑与，同位全为1，则结果的同位数为1
| （位或）：等同于逻辑或，同位有一个1，则结果的同位数为1
^（异或）：若相同则为0
<<（左移）：左边的数乘以两个右边的数
>>（右移）：左边的数除以两个右边的数，取整
以上两种区别：&&和||是短路运算符，有时左边的表达式可以代表整个表达式的结果，那么右边的表达式就被短路，不参与运算；&和|，是非短路运算，也就是说左右两边都要参与运算，且只有在位运算中，数值0和1与false和true能互相转换
++和--只能用于整数、字符类型的变量，不能用于常量和表达式，例：(x+1)++(x)不可以
%取模运算，表达式的结果的正负由被除数决定
+：1）若两边为数值，执行加法运算；2）若两边有字符串出现，则是连接字符
运算符的优先级（左结合：从左往右算）

Math.random()得到的是一个0.0-1.0的数

程序控制结构

switch：表达式运算的结果可以是byte，short，int，char，String的一种

outer标签：

...
outer:for(int i=0;i<3;i++){
    inner:for(int j=0;j<3;j++){
        if(j==1){
            continue outer;  //两层全退
        }
...
}

第三章数组

3.2 数组的声明

//动态数组创建方式
int t[];
t=new int[3];
//或
int t[]=new int [3];
//静态数组创建方式
int t[]={1,2,3};

声明数组时，不能指定数组的长度
数值类型的数组创建时默认的值为0，布尔类型为false，引用类型为null
浅拷贝：多个数组名共用一块堆内存空间，即指向同一块存储内存
```
int[] a={1,2,3};
int[] b=a;
a[0]=88;
System.oyt.println(b[0]);
```

深拷贝：每个数组在堆内存中有不同的空间

public static void main(String[] args) {
 		int[] array1 = {1, 2, 3, 4, 5};
        int[] array2 = {5, 6, 7, 8, 9};
        //把array2数组复制到array1中
        System.arraycopy(array2, 0, array1, 1, 4);//0，1是位置，4是多少个
        System.out.println(Arrays.toString(array1));
    //结果为[1,5,6,7,8]
}

多维数组的声明：int [] [] a; int a[][] ; int [] a[] ;（声明中不可以有数组）
多维数组的创建：静态创建：int[][]a; a={{1,2,3},{10,20,30}};或int[][]a={{1,2,3},{10,20,30}};
动态创建：int[][]a;a=new int [2][3];或int a=new int [2][3];
注意： int t[][]={{1,2,2},{2,3},{1,3}};
相当于：int t[][]=new int[3][]//必须要有行; t[0]=new int[3]; t[1]=new int[2]; t[2]=new int[2];
增强循环：使用范围：用来遍历集合和数组(必须有遍历目标，目标只能是集合或者数组)，所有单列表集合都可以使用增强for循环。

for(ElementType element: arrayName) 
{ //集合或数组的数据类型 变量名：集合名/数组名
	System.out.println(变量名)；
};
//一维数组
	 int[] num = {1,2,3,4,5,6};
     for(int i :num){   //集合或数组a : 数组名称num
         System.out.println("元素："+ i); 
     } 
//二维数组
     int [][]b=new int [3][];
	 b[0]=new int[1];
	 b[1]=new int[2];
	 b[2]=new int[3];
     for(int[] i:b){
        for(int j:i){
            System.out.print(j+" ");
        }
        System.out.println();
      }

错题：

第四章类与对象

4.1面向对象程序设计概述

面向对象的特点：封装、继承、多态
类：对一类型事物的属性和行为进行描述---类的定义
对象：符合类描述的具体实例
设计Java程序的一般步骤：1）设计主类；2)设计描述类 3）在主类中创建对象，通过对象.的形式使用属性 4）构造方法创造对象，无特殊说明，则取默认值，可以在主方法中修改
封装性：类的定义本身就是封装性的表现

4.3对象

对象的创建：类名对象名 =内存分配符构造方法([参数列表])
对象可以理解为一种数据结构，具有才做数据的方法
构造方法：1）通过构造方法来创建对象 2）构造方法名和类名相同，没有返回值 3）所有的类里面都有构造方法，如果不是明确设计，系统会提供一个默认的构造方法 4）构造方法可以做成员变量的初始化
构造方法和类名相同，参数列表可以有（带参构造），也可以没有（默认构造）
成员变量初始化：1）属性变量也叫成员变量 2）定义的时候可以直接初始化(赋值)，否则为null或0 3）在构造方法里初始化 4）构造方法创建对象时会先执行（2）再执行（3）
对象的内存分配：1）当形参变量名和属性变量名相同时，在赋值时，可以再属性变量前加this区别于形参变量 2）类的对象在内存中的表现形式会在内存中创建两块内存； 2)-1：一块存放对象变量名（存放实体对象的内存地址） 2)-2：另一块内存存放真正的对象实体（含有个属性的值）因此对象变量指向对象实体，可以代表对象实体，但不是对象实体，对象变量实际上是地址（引用） 3）简单类型变量在内存的表现：int i=10

4.4变量

1.局部变量：

在方法内定义的变量成为局部变量，方法的参数也是局部变量

2.实例变量：

属性，在类中方法外定义的非static修饰的变量

3.类变量：

类的属性--成员变量： 1）实例变量(不加static)：当对象(实例)被创建时，实例变量被分配内存，且各个对象的实例变量互不影响，静态方法不能直接访问非静态的实例变量或方法 2）成员变量(加static)：类变量/静态变量，当类加载到内存，类变量属于所有对象，被分配内存，所有对象共享该类变量，且早于对象创建 3）类变量还可以用类名来访问，实例变量通过对象名访问（s1.run）
类的方法--成员方法：1）实例方法(不加static)--实例方法，当对象(实例)被创建时，实例方法被分配入口地址 2）成员方法(加static)--类方法/静态方法，当类加载到内存，类方法被分配到入口地址 3）实例方法通过对象名访问，类方法可以通过对象名和类名访问
实例方法可以访问实例变量、实例方法类方法可以访问类变量，调用类方法；但类方法不可以访问实例变量，不可以调用实例方法；但实例方法可以访问类变量、调用类方法

类方法在主方法中，可以不建立对象就使用，但实例方法需要建立对象才能使用

public class MathUtils {  
    // 这是一个类方法（静态方法）  
    public static int add(int a, int b) {  
        return a + b;  
    }  
      
    // ... 其他类方法 ...  
}  
  
// 使用类方法  
int sum = MathUtils.add(3, 4); // 不需要创建MathUtils的实例  
System.out.println(sum); // 输出 7

4.5方法

1.类中的方法

构造方法（没有返回值说明）
返回值说明为void的方法（无return）
返回值说明为其他类型（简单类型或类类型），如下
```
class College(){
    ....
}
class Student(){
    College p2(){
        return new College();
    }
}
```
构造方法的作用：一是创建对象；二是为父类成员变量初始化

2.关于方法的参数

方法参数不同指的是类型和个数的不同，和用什么变量无关

3.方法的重载

在同一个类里，方法名相同，方法参数的类型或个数不同的用法成为方法的重载

方法的形参不同(个数不同、类型不同、顺序不同)，注意：不包括参数名称不同，不包括返回类型不同

构造方法可以重载：

class Person{
    Person(){
        ...
    }
    
    Person(int a){
        ...
    }
}

普通方法的重载：

class P{
    int P(..){
        ...
    }
    
    void P(){
        ...
    }
}

重复不允许（方法名相同，参数的类型和个数相同），以下为错误代码

class Person{
    void P(double a){
        ...
    }

    double P(double b){
        ...
    }
}

为什么要用重载呢？是动态的一种，同一个方法名的不同表现

this.的用法：

当前类的对象（方法参数和成员变量同名时

class Person{
    String name;
    Person(String name){
        this.name=name;
    }
}

构造方法之间的相互调用： “this()”：调用本类中其他重载的构造方法

4.传递参数

传值调用：当方法调用中，传递的参数类型是简单类型，形参的改变不影响实参。原因是形参是对实参的复印
传址调用：当方法调用中，传递的参数类型是类类型（引用类型），形参的改变就是实参的改变。原因是形参和实参都是地址，指向同一实体

5.Object类

在Java中，extends Object 通常是不必要的，因为所有的Java类都隐式地继承自 Object 类。

6.方法的返回值类型

7.错题

A:用 new 运算符创建的对象在没有任何引用指向它时（即不可达时），就会成为垃圾回收的候选对象。JVM 会在适当的时候运行垃圾回收器来回收这些不再使用的对象所占用的内存。JVM 退出时，所有内存都会被释放，但这不意味着只有那时才进行垃圾回收。

B:判断一个对象是否可以被垃圾回收的条件是它是否从根（roots）开始不可达。

第五章继承与多态

权限

1）类的权限

类无private、protected权限
无public是默认权限(友好权限)
同一个包中的类可以相互访问
不同包中的类，如果可以导入(import a.p)，则可以访问，public可导入

2）类中的变量和方法的权限

public、protected、默认、private(可见由高到低)

同一类中，所有权限皆可访问；同一包中的不同类，可以访问默认及以上权限的变量和方法
不同包中的不同类，在可导入的前提下，只可以访问public权限
不同包中的不同父子类，在可导入的前提下，子类可以访问父类的保护及以上权限
this：当前类的对象，super：当前类的父类的对象

private

私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。
声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。
private不能修饰外部类

public

被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。
如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包。
由于类的继承性，类所有的公有方法和变量都能被其子类继承。

protected

子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；
子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。

这是可以的。在第2行，SuperDuper类中的add方法被声明为private，这意味着它只能在SuperDuper类内部被访问。然后，在Sub类中，你可以声明一个名为add的protected方法，这并不会与父类的private add方法发生冲突，因为父类的private方法对于子类是不可见的。但请注意，这并不是重写，因为子类并没有“看到”父类的private方法。

1.继承

为了减少程序代码的冗余，增加程序的可重用性，引入继承

子类可以继承父类的属性和方法

class A extends B{
}

继承中的问题：

构造方法不能被子类，只能被调用，而且必须被调用，必须在子类构造方法中被调用，放在最前面

继承中的权限：private不能被继承，但可以转为public

class P{
    private show(){
        ...
    }
    public prt(){
        show();
    }
}
class 主类{
    ...
    s.show();//可用
}

包的问题：包用来对类进行管理--实质是目录，没有特殊说明的类放在缺省包里(default)；包的层次用“.”来表示，package a.b; 在a包里的b包下

继承的构造方法：

class xx estends XX{
    xx(){
        super();
    }
}

子类继承父类的属性和方法（私有变量和方法不能继承，构造方法不能继承，但构造方法必须在子类的构造方法第一句调用）
变量的隐藏：子类定义父类同名变量（该变量不继承父类，如果想用父类的那个同名变量，使用super.变量）
方法的隐藏：子类定义父类同名方法，则不继成父类的方法，若想使用super即可

错题1

在第15行中，你试图通过传递一个字符串参数来实例化Demo类的对象，但是Demo类没有定义一个接受字符串参数的构造方法。它只继承了父类Example的无参构造方法（因为子类如果没有显式地定义构造方法，则会自动继承父类的无参构造方法）。由于Demo类中没有带参数的构造方法，因此你不能在创建Demo对象时传递参数。这会导致编译错误。

要修复这个问题，你需要在Child类的构造函数中显式地调用Parent类的带参数构造函数，即使你不打算使用那个参数。例如：

public class Child extends Parent {  
    Child(String s) {  
        super("some string"); // 显式调用父类的带参数构造函数  
        // s = "child"; // 这行代码不会影响Parent类中的任何状态  
    }  
    // ... 其他方法 ...  
}

错题2

这里有两个关键点：

Base b = new Base(); 这行代码是合法的，因为它创建了一个Base类的对象，并将其引用赋值给了Base类型的变量b。
Sub s = (Sub) b; 这行代码试图将一个Base类型的对象引用强制转换为Sub类型，并赋值给Sub类型的变量s。但是，由于b引用的是一个Base类型的对象，而不是Sub类型的对象（或Sub类型的子类的对象），所以这种转换是不安全的，并且会在运行时抛出ClassCastException。

重写、重载、重复

重写（覆盖）：方法名一样，参数返回值类型一样、权限不能降低，类方法不能被重写重写权限不能降低是为了确保子类能够完全替代父类，不会出现因为权限问题导致的功能受限或错误。
重载：同一个类中，方法名一样，参数(个数或类型)不一样，但返回值权限、参数变量名都不考虑
重复：同一个类中，方法名一样，参数类型、个数都一样

实例变量的隐藏

实例变量的隐藏是指当子类和父类都有同名的实例变量时,子类的实例变量把父类的实例变量隐藏起来,子类对象访问时,优先访问子类中定义的实例变量。

但当我们通过父类类型的引用来访问这个变量时，我们仍然访问的是父类中的变量，而不是子类中的变量。

2.引用类型的转换

上转型

子类对象赋给父类的变量(引用)；
实质：把子类当作父类来看，例把老虎当作普通动物来看；
子类新增的变量将不能使用，新增的方法也不能用，但会执行子类重写的方法
好处：插拔式操作，多态的表现
转换语法规则：1）子类型子类型引用变量(对象名) =new 子类构造方法（）；
父类型父类型引用变量= 子类型引用变量；
2）父类型父类型引用变量 = new 子类构造方法（）；

回调(动态上转型)

3.多态

静态多态：和方法重载有关，是程序编译阶段确定的多态，表现形式为：在类中或者具有继承关系的父子类中有多个同名的方法，方法由于接收的参数类型不同，而产生的结果不同的行为结果。
动态多态：和方法重写有关，是在运行阶段确定的多态，表现形式为：在继承关系中，子类方法对父类方法重写，当同名方法被不同类型对象调用时，会产生不同的行为结果。
回调：设计一个方法，其参数包括类变量，调用时可传一个子类对象（上转型），回调子类重写的方法

4.final修饰符

修饰类：最终类不能被继承，即不能有子类；
修饰方法：最终方法不能被方法重写
修饰变量：该变量的值不可改变，可以理解为特殊的常量，final修饰的变量在定义时必须初始化（即必须赋值），并且一旦赋值后就不能再修改。

错题3

第六章抽象类与接口

6.1 抽象类

能够创建对象的类--是一个具体已经实现的类（具体类）不能创建对象的类---是一个没有完全实现的类（抽象类）抽象类具体形式--abstract 修饰类--抽象类
有方法体的方法称为已经实现的方法{ } 没有方法体的方法称为没有实现的方法(抽象方法) 抽象方法具体形式--abstract 修饰方法--抽象方法
抽象方法和抽象类的关系：含有抽象方法的类一定是抽象类，抽象类可以不含有抽象方法
抽象方法没有方法体
抽象的父类，其子类可以重写(实现)父类的抽象方法，如果不实现(重写)，继续保持抽象交给孙类
抽象的上转型==普通类的上转型，前提：子类必须重写父类的抽象方法
abstract和private冲突：
作为abstract方法，它要求子类必须提供实现。
作为private方法，它阻止了子类访问和重写它。
abstract只修饰类和方法

零碎知识点

方法体是指方法声明后的“{ }”中的代码块，即使“{ }”中没有代码，也算有方法体
类方法是在类加载时就要确定的方法，不可以成为抽象方法，即abstract和static不能同时使用
抽象类不能实例化，不能创建对象
抽象类中的其他修饰符可以是访问权限修饰符，不可以是final，final和abstract也不能同时使用，因为final修饰的类为最终类，不可以有子类，而abstract修饰的类只能作为父类
修饰符省略了public
单独定义抽象类型的引用变量是允许的：因为抽象类型的引用变量作为父类使用时，可以采用上转型的方式间接调用子类中重写的方法
抽象类中有构造方法，构造方法的作用：1.创建对象；2.作用是为父类的成员变量初始化
单独定义抽象类型的引用变量是容许的

6.2 接口

接口：比抽象类还抽象，定义 interface A{ }
接口和接口里的方法必须是抽象的，必须是public abstract 但可省略
接口在Java中只有公有（默认）一种访问权限
接口里变量必须是 public static final (也就是常量)，可省略；int a=10;接口中的成员（无论是字段还是方法）都必须是公开的（public），以确保它们可以在实现类中被访问和使用。
接口的关系：接口可以实现多重继承，即一个接口可以有多个父接口，而类是单继承
接口中的常量有三种访问方式：接口名.常量；类名.常量(类和接口必须有实现关系)；对象名.常量

类和接口的关系

类可以实现接口(一种特殊继承相关的方法和属性)，需要实现即重写所有的继承的抽象方法，如果不全实现，则该类继续为抽象类
类可以实现多个接口
上转型等同于抽象类和普通类

抽象类实现接口

// 接口A  
interface A {  
    void methodA();  
}  
  
// 另一个接口B  
interface B {  
    void methodB();  
}  
  
// 抽象类C实现了接口A和B  
abstract class C implements A, B {  
    // 必须提供接口A中定义的方法的具体实现  
    @Override  
    public void methodA() {  
        System.out.println("Implementing methodA from interface A");  
    }  
  
    // 可以选择不提供接口B中定义的方法的具体实现，保持其为抽象  
    // 这样，任何继承C的类都必须提供methodB的具体实现  
    // @Override  
    // public void methodB() {  
    //     // 实现细节  
    // }  
  
    // 或者，可以将methodB也声明为抽象方法  
    @Override  
    public abstract void methodB();  
}  
  
// 具体的类D继承自抽象类C，并提供接口B中方法的实现  
class D extends C {  
    @Override  
    public void methodB() {  
        System.out.println("Implementing methodB from interface B");  
    }  
}  
  
public class Main {  
    public static void main(String[] args) {  
        D d = new D();  
        d.methodA(); // 输出：Implementing methodA from interface A  
        d.methodB(); // 输出：Implementing methodB from interface B  
    }  
}

错题

无论是抽象类还是接口，成员变量（非静态和非final）都不能在声明时直接初始化。它们需要在构造函数（对于抽象类）或实现类的相应字段中初始化。但是，静态变量（无论是抽象类还是接口）可以在声明时直接初始化，或者在静态初始化块中初始化。
但由于存在默认方法的特殊情况，因此严格来说，表述可能有误
A:接口在Java中是一个完全抽象的类，它只包含抽象方法的声明，不包含方法的具体实现。
B:这三个修饰符在接口中定义变量时是可选的
D:关于方法的可见性，接口中的方法默认是public的，因此实现类在实现这些方法时也必须是public的。属于重写降低权限。

//抽象方法继承抽象方法
// 抽象类B  
abstract class B {  
    void nonAbstractMethod() {  
        System.out.println("B's non-abstract method");  
    }  
  
    abstract void abstractMethod();  
}  
  
// 抽象类A继承自B  
abstract class A extends B {  
    // A可以覆盖B中的非抽象方法  
    @Override  
    void nonAbstractMethod() {  
        System.out.println("A overrides B's non-abstract method");  
    }  
  
    // A可以提供B中抽象方法的具体实现  
    // 如果这样做，A就不再是抽象的  
    // void abstractMethod() { /* ... */ }  
  
    // 或者，A可以选择不实现B中的抽象方法  
    // 这样A仍然是抽象的  
}  
  
// 具体的类C继承自A，并提供抽象方法的具体实现  
class C extends A {  
    @Override  
    void abstractMethod() {  
        System.out.println("C implements A's abstract method");  
    }  
}  
  
public class Main {  
    public static void main(String[] args) {  
        // 因为C提供了所有抽象方法的具体实现，所以可以创建C的实例  
        C c = new C();  
        c.nonAbstractMethod(); // 输出：A overrides B's non-abstract method  
        c.abstractMethod();    // 输出：C implements A's abstract method  
    }  
}

B:如果一个类（无论是父类还是子类）实现了某个接口，那么它就继承了该接口中定义的所有常量和抽象方法（注意：接口中不能定义非静态的实例字段，但可以定义静态常量）。子类不需要“再次实现”该接口来继承这些常量和抽象方法。但是，这里有一个关键点需要注意：如果父类是一个抽象类，并且它实现了某个接口但没有为该接口中的所有抽象方法提供具体实现，那么任何继承这个抽象类的非抽象子类都必须为这些未实现的抽象方法提供具体实现。
C:若这个类为抽象类，可以部分实现接口的抽象方法，但剩下的抽象方法需要抽象类再次声明

第七章包

7.1 包

包声明语句只能出现一次，且必须在源文件第1行
引用包语句可以在源文件出现多次
常用的系统包：java.lang，自动引入其所有类或接口，不需要import语句

7.2 访问权限修饰符

权限

7.4 包装类

包装类能够完成除Boolean类型外的数据类型之间的相互转换
包装成整数类，再变回简单类型

package a://只能放在第一句
import a.b.B://只能放在包后
public class T{
    public static void main (Stringil args) {
        int 1 =10://
        Integer il=new Integer（i）：//包装成整数类，简单类型没有属性和方法
        i1.byteValue（）：//整数类i1调用方法
        Integer i2=new Integer (10) ;
        System. out println (i2. intValue ()) ;
        int i3=i1.intvalue （）；//变回简单类型
// float--Float, double--Double
    }
}

基本数据类型与包装类型的自动转换

public class T{
    public static void main (String[] args) {
        Integer x=10;
        int y=20;
        Integer z=x+y;//z为30
    }
}

基本数据类型和字符串的转换

public static void main(String[] args){
    String x="3.14";
    String y="10";
    String z="3w";
    double a=Double.parseDouble(x);
    int b=Integer.parseInt(y);
    System.out.println(a+" "+b);//3.14 10
    int c=Integer.parseInt(z);
    system.out.println(c);//Exception in thread "main" java.lang.NumberFormatException: For input string: "3w"
}

包装类中的方法重写

public static void main(String[] args) {
    Integer x=10;
    Integer y=10;
    Test t1=new Test();
    Test t2=new Test();
    System.out.println(x==y);//==用于判断非数值的地址和数值的数值
    System.out.println(x.equals(t2));//用来判断地址
    System.out.println(t1==t2);//两个对象，肯定不同
    System.out.println(t1.eaquals(t2));
    System.out.println(x.toString());//输出地址，但在包装类中重写成输出值
    System.out.println(t1.toString());
}