java基础-（三）-java基础语法

零，基本语法

1，基本约定

大小写敏感：Java 是大小写敏感的 类名：类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。 方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。 源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。（如果文件名和类名不相同则会导致编译错误）。 主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。 

2，修饰符

修饰符用来定义类、方法或者变量，通常放在语句的最前端。
访问控制修饰符：

default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。 private : 在同一类内可见,子类不可见。使用对象：变量、方法。 注意：不能修饰类（外部类） public : 对所有类可见。使用对象：类、接口、变量、方法 protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。 

非访问修饰符

static 修饰符，用来修饰类方法和类变量。 final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。 abstract 修饰符，用来创建抽象类和抽象方法。 synchronized 和 volatile 修饰符，主要用于线程的编程。 

3，数组

数组是储存在堆上的对象，可以保存多个同类型变量。 

数组的遍历可以使用for循环,也可以使用for each:

int[] ns = { 
    1, 4, 9, 16, 25 }; for(int n:ns) { 
    System.out.println(n); } 

数组的打印如果直接打印的话,会是第一个元素的内存地址,需要使用如下方法:

System.out.println(Arrays.toString(ns));//[1, 4, 9, 16, 25] 

4，枚举

枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的 bug。 例如，我们为果汁店设计一个程序，它将限制果汁为小杯、中杯、大杯。这就意味着它不允许顾客点除了这三种尺寸外的果汁。 class FreshJuice { 
    enum FreshJuiceSize{ 
    SMALL, MEDIUM , LARGE } FreshJuiceSize size; } public class FreshJuiceTest { 
    public static void main(String[] args){ 
    FreshJuice juice = new FreshJuice(); juice.size = FreshJuice.FreshJuiceSize.MEDIUM ; } } 

5，关键字

6，注释

public class HelloWorld { 
    /* 这是第一个Java程序 * 它将输出 Hello World * 这是一个多行注释的示例 */ public static void main(String[] args){ 
    // 这是单行注释的示例 /* 这个也是单行注释的示例 */ System.out.println("Hello World"); } } 

7，继承

8，接口

9，Java 源程序与编译型运行区别

10，基本数据类型

基本数据类型和js的基本数据类型差不多，定义要更严谨一些。

使用final修饰的变量是常量,不可修改:finl int a=2; 

如果懒得写类型定义,可以用var代替,编译器会自动识别出类型:

var sb=new StringBuilder(); 等价于: StringBuilder sb = new StringBuilder(); 

11，变量

变量从本质上讲，就是内存中的一小块区域，用来暂存数据。
定义变量：数据类型 变量名=变量值
例如int a=19。

1，定义的变量名字不能重复 2，变量未赋值时不能使用 3，long类型的变量定义的时候，为了防止整数过大，后面要加L,如：long a=L(因为默认是int类型，怕超过int的范围) 4，float类型的变量定义的时候，为了防止类型不兼容，后面要加F，如：float a=3.14F(因为默认是double) 

局部变量：方法体中 类变量（静态变量）：类中、方法体外，用static修饰 实例变量（成员变量）（非静态变量）：类中，方法体外，不用static修饰，属于实例的，得通过实例才能访问。 

public class Variable{ 
    static int allClicks=0; // 类变量,无论一个类创建了多少个对象，类只拥有类变量的一份拷贝 //静态变量除了被声明为常量外很少使用，静态变量是指声明为 public/private，final 和 static 类型的变量。静态变量初始化后不可改变。 //大多数静态变量声明为 public 类型 String str="hello world"; // 实例变量，实例变量在对象创建的时候创建，在对象被销毁的时候销毁；访问修饰符可以修饰实例变量； //实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有(private)。通过使用访问修饰符(public )可以使实例变量对子类可见； public void method(){ 
    int i =0; // 局部变量，访问修饰符不能用于局部变量，局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。 } } 

非静态变量不能在该类的主函数中直接读取，而是需要新建类后才可以。

public class MyTest2 { 
    String version = "1.5.1";//非静态变量 private void getVersion(){ 
    System.out.println(version); } public static void main(String[] args) { 
    MyTest2 test=new MyTest2();//需要实例化之后才能读取 test.getVersion(); } } 

12，变量的类型转化

自动类型转化：将表示范围小的值或变量转化为表示范围大的变量。

byte,short,char—> int —> long—> float —> double 

public class ZiDongLeiZhuan{ 
    public static void main(String[] args){ 
    char c1='a';//定义一个char类型 int i1 = c1;//char自动类型转换为int System.out.println("char自动类型转换为int后的值等于"+i1); } } 

强制类型转化：将表示范围大的值或变量转化为表示范围小的变量。

int i1 = 123; byte b = (byte)i1;//强制类型转换为byte 

13，运算符

算术运算符

+，-，*，/，％，++，-- 

关系运算符

==，!=，>,<,<=,>= 

逻辑运算符

&，|，^,! &&:短路与，和&一样，但是如果左边为真，右边执行，如果左边为假，右边不执行。 ||：短路或，和|一样，但是左边为假，右边执行，如果左边为真，右边不执行。 

instanceof 运算符
该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。

String name = "James"; boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真 

一，对象和类

1，类的状态和方法

类：类是一个模板，它描述一类对象的行为和状态 对象：是类的一个实例，她首先具备该类的行为和状态，并且可以有自己的行为和状态。 

定义一个类：

public class Dog { 
    String breed; int size; String colour; int age; void eat() { 
    } void run() { 
    } void sleep(){ 
    } void name(){ 
    } } 

一个java类中，可以有以下几种类型变量：

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。 成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。 类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。 

一个类可以拥有多个方法，在上面的例子中：eat()、run()、sleep() 和 name() 都是 Dog 类的方法。

2，构造方法

每个类都有构造方法。如果没有显式地为类定义构造方法，Java 编译器将会为该类提供一个默认构造方法。
在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

public class Puppy{ 
    public Puppy(){ 
    } public Puppy(String name){ 
    // 这个构造器仅有一个参数：name } } 

3，创建对象

类名 对象名称 = new 类名(); 

public class Main { 
    //Main类的构造方法 public Main(String name){ 
    //这个构造器仅有一个参数：name System.out.println("小狗的名字是 : " + name ); } public static void main(String[] args) { 
    // 下面的语句将创建一个Main对象 Main myPuppy = new Main( "tommy" ); } } 

4，访问实例变量和方法

和js差不多，Obj.变量名，Obj.方法名（）

public class Main{ 
    int puppyAge;//类中的变量 // 这个构造器 public Main(String name){ 
    System.out.println("小狗的名字是 : " + name ); } //类的方法 public void setAge( int age ){ 
    puppyAge = age; } public int getAge( ){ 
    System.out.println("小狗的年龄为 : " + puppyAge ); return puppyAge; } //主方法 public static void main(String[] args){ 
    /* 创建对象 */ Main myPuppy = new Main( "tommy" ); myPuppy.setAge( 2 ); myPuppy.getAge( ); System.out.println("变量值 : " + myPuppy.puppyAge ); } } 

5，创建类需要注意的

一个源文件中只能有一个 public 类 一个源文件可以有多个非 public 类 源文件的名称应该和 public 类的类名保持一致 

public class Main{ 
    int puppyAge; public Main(String name){ 
    // 这个构造器仅有一个参数：name System.out.println("小狗的名字是 : " + name ); } public void setAge( int age ){ 
    puppyAge = age; } public int getAge( ){ 
    System.out.println("小狗的年龄为 : " + puppyAge ); return puppyAge; } public static void main(String[] args){ 
    /* 创建对象 */ Main myPuppy = new Main( "tommy" ); myPuppy.setAge( 2 ); myPuppy.getAge( ); System.out.println("变量值 : " + myPuppy.puppyAge ); Test test1=new Test(); test1.setAge(6); test1.outTest(); } } class Test{ 
    int a; void setAge( int age ){ 
    a = age; } void outTest(){ 
    System.out.println("测试另一个类: " + a ); } } 

6，java包的引入和使用

import java.io.*; 

新建一个类Dog.java：

public class Dog { 
    int age; public Dog(String name){ 
    // 这个构造器仅有一个参数：name System.out.println("小狗的名字是 : " + name ); } public void setAge(int a){ 
    age=a; } public int getAge(){ 
    return age; } } 

在另一个同目录下的类Mytest2.java中直接使用：

public class MyTest2 { 
    public static void main(String[] args) { 
    Dog keJi=new Dog("小白"); keJi.setAge(9); int dogAge=keJi.getAge(); System.out.println("小狗的年龄是"+dogAge); } } 

二，语句结构

1,while循环

//只要布尔表达式为 true，循环就会一直执行下去。 while( 布尔表达式 ) { 
    //循环内容 } 

2,do…while 循环

//至少会执行一次,直到条件为false do { 
    //代码语句 }while(布尔表达式); 

3,for循环

for(初始化; 布尔表达式; 更新) { 
    //代码语句 } 

Java5 引入了一种主要用于数组的增强型 for 循环。

Java 增强 for 循环语法格式如下:

for(声明语句 : 表达式) { 
    //代码句子 } 

int [] numbers = { 
   10, 20, 30, 40, 50}; for(int x : numbers ){ 
    System.out.print( x ); } 

4,break 关键字
break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。
break 跳出最里层的循环，并且继续执行该循环下面的语句。

 for(int b=0;b<5;b++){ 
    System.out.println(b); if(b>2){ 
    break; } } 

5，continue 关键字

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

 for(int b=0;b<5;b++){ 
    if(b==2){ 
    continue; } System.out.println(b); } 

6，switch……case

switch(expression){ 
    case value : //语句 break; //可选 case value : //语句 break; //可选 //你可以有任意数量的case语句 default : //可选 //语句 } 

三，内置类

1,Number类

2，Math类

Math有提供一些常用的数学方法：

public class MyTest2 { 
    public static void main(String[] args) { 
    double a=1.45; System.out.println(Math.floor(a));//1.0 } } 

Math.parseInt()：将字符串解析为int类型。 Math.abs():返回参数的绝对值。 Math.ceil():返回大于等于( >= )给定参数的的最小整数，类型为双精度浮点型 Math.floor():返回小于等于（<=）给定参数的最大整数 。 Math.round():它表示四舍五入，算法为 Math.floor(x+0.5)，即将原来的数字加上 0.5 后再向下取整，所以，Math.round(11.5) 的结果为12， 

3，枚举类

Java 枚举是一个特殊的类，一般表示一组常量。

public class MyTest2 { 
    public static void main(String[] args) { 
    System.out.println(Color.RED); //或者 Color test=Color.RED; System.out.println(test); } } enum Color { 
    RED, GREEN, BLUE; } 

values() 返回枚举类中所有的值。 ordinal()方法可以找到每个枚举常量的索引，就像数组索引一样。 valueOf()方法返回指定字符串值的枚举常量。 

public class MyTest2 { 
    public static void main(String[] args) { 
    Color test=Color.RED; System.out.println(test.ordinal());//返回它在Color中对应的索引 System.out.println(Color.valueOf("RED"));//返回它在Color中对应的值 } } enum Color { 
    RED, GREEN, BLUE; } 

for循环遍历枚举

public class MyTest2 { 
    public static void main(String[] args) { 
    Color [] arr= Color.values();//取得Color的值形成数组 for (Color test :arr){ 
    System.out.println(test); } } } enum Color { 
    RED, GREEN, BLUE; } 

四，数组

1，创建数组

dataType[] arrayRefVar = new dataType[arraySize];//int [] test=new int[]{3, 1, 2, 6, 4, 2} dataType[] arrayRefVar = { 
   value0, value1, ..., valuek};//double[] myList = {1.9, 2.9, 3.4, 3.5}; 

2，遍历数组

// 打印所有数组元素 for (int i = 0; i < myList.length; i++) { 
    System.out.println(myList[i] + " "); } //或者 // 打印所有数组元素 for (double element: myList) { 
    System.out.println(element); } 

3，数组作为函数的参数

public class MyTest2 { 
    static void printArray(int[] array){ 
    for (int i = 0; i < array.length; i++) { 
    System.out.print(array[i] + " "); } } public static void main(String[] args) { 
    int[] myList = { 
   1, 2, 3, 3}; printArray(myList); } } 

4，数组作为函数的返回值

之前我们没有返回值时，用的是void，现在有返回值了，则应该是返回值的类型定义：

public class MyTest2 { 
    static int[] printArray(int[] array){ 
    for (int i = 0; i < array.length; i++) { 
    System.out.print(array[i] + " "); } return new int[]{ 
   3, 1, 2, 6, 4, 2}; } public static void main(String[] args) { 
    int[] myList = { 
   1, 2, 3, 3}; printArray(myList); } } 

5，Arrays类

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

给数组赋值：通过 fill 方法。 对数组排序：通过 sort 方法,按升序。 比较数组：通过 equals 方法比较数组中元素值是否相等。 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。 

五，java日期时间

java.util 包提供了 Date 类来封装当前的日期和时间。

Date( )//返回当前时间 Date(long millisec)//返回从 1970 年 1 月 1 日起的时间。参数是毫秒数 

六，面向对象

1，类的继承格式

class 父类 { 
    } class 子类 extends 父类 { 
    } 

实例：

public class MyTest2 { 
    public static void main(String[] args) { 
    Penguin test=new Penguin("小企鹅",5); test.getName();//小企鹅 } } class Animal { 
    public String name; private int id; //构造函数初始化 public Animal(String myName, int myid) { 
    name = myName; id = myid; } public void eat(){ 
    System.out.println(name+"正在吃"); } public void sleep(){ 
    System.out.println(name+"正在睡"); } public void introduction() { 
    System.out.println("大家好！我是"+ id + "号" + name + "."); } } class Penguin extends Animal{ 
    public Penguin(String myName,int myid){ 
    super(myName, myid);//调用超类的构造方法 } public void getName(){ 
    System.out.println(name); } } 

子类拥有父类非 private 的属性、方法。 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。即同名覆盖。 子类可以用自己的方式实现父类的方法。 Java 的继承是单继承，但是可以多重继承， 

2，super关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

public class MyTest2 { 
    public static void main(String[] args) { 
    Penguin test=new Penguin("小企鹅",5); test.childEat(); } } class Animal { 
    private String name; private int id; //构造函数初始化 public Animal(String myName, int myid) { 
    name = myName; id = myid; } public void eat(){ 
    System.out.println(name+"正在吃"); } } class Penguin extends Animal{ 
    public Penguin(String myName,int myid){ 
    super(myName, myid);//调用超类的构造方法 } void childEat(){ 
    super.eat();//调用超类的方法 } } 

3，this关键字

this关键字：指向自己的引用。

class Dog extends Animal { 
    void eat() { 
    System.out.println("dog : eat"); } void eatTest() { 
    this.eat(); // this 调用自己的方法 } } 

4，final修饰符

final class 类名 { 
   //类体} 

声明方法：

修饰符(public/private/default/protected) final 返回值类型 方法名(){ 
   //方法体} 

5，构造器

public class MyTest2 { 
    public static void main(String[] args) { 
    Penguin test=new Penguin("小企鹅",5); test.childEat(); } } class Animal { 
    private String name; private int id; //构造函数初始化 public Animal(String myName, int myid) { 
    name = myName; id = myid; } public void eat(){ 
    System.out.println(name+"正在吃"); } } class Penguin extends Animal{ 
    public Penguin(String myName,int myid){ 
    super(myName, myid);//调用超类的构造方法 } void childEat(){ 
    super.eat();//调用超类的方法 } } 

6，重写

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

public class MyTest2 { 
    public static void main(String[] args) { 
    Animal a = new Animal(); // Animal 对象 Animal b = new Dog(); // Dog 对象 a.move();// 执行 Animal 类的方法：动物可以移动 b.move();//执行 Dog 类的方法：狗可以跑和走 } } class Animal{ 
    public void move(){ 
    System.out.println("动物可以移动"); } } class Dog extends Animal{ 
    public void move(){ 
    System.out.println("狗可以跑和走"); } } 

如果子类的方法中，要调用父类的方法，还是使用super来访问。

7，重载

和子类重写父类的方法不同的是，重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
它的作用是可以定义多个同名的方法，只是参数不同罢了。

public class MyTest2 { 
    public static void main(String[] args) { 
    Animal a = new Animal(); // Animal 对象 a.move();// 动物可以移动 a.move("小白");//小白可以移动 } } class Animal{ 
    public void move(){ 
    System.out.println("动物可以移动"); } public void move(String name){ 
    System.out.println(name+"可以移动"); } } 

8，多态

允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）
而重写，是实现多态的一种重要方式。
实现多态的三个必要条件：

继承 重写 父类对子类引用：该引用才既能可以调用父类的方法，又能调用子类的方法 

实例：

public class MyTest2 { 
    public static void main(String[] args) { 
    Animal bird1 = new Bird();//这里向上转型为Animal，并且指向子类的引用 bird1.eat();//小鸟吃的是虫子 Animal monkey1 = new Monkey();//这里向上转型为Animal，并且指向子类的引用 monkey1.eat();//猴子吃的是香蕉 doSleep(new Monkey());//这里也是向上转型 } public static void doSleep(Animal animal) { 
    // 此时的参数是父类对象，但是实际调用时传递的是子类对象，就是向上转型。 animal.sleep(); } } class Monkey extends Animal { 
    void eat() { 
    System.out.println("猴子吃的是香蕉"); } public void sleep() { 
    System.out.println("猴子正在睡觉"); } } class Bird extends Animal { 
    void eat() { 
    System.out.println("小鸟吃的是虫子"); } void fly(){ 
    System.out.println("小鸟会飞"); } public void sleep() { 
    System.out.println("小鸟正在睡觉"); } } abstract class Animal { 
    void eat() { 
    System.out.println("动物吃东西的方法"); } public void sleep() { 
    System.out.println("小动物在睡觉"); } } 

值得注意的是Animal bird1 = new Bird();它不是在创建新的Bird实例对象，而是向上转型，这样父类实例bird1就有了指向子类Bird的引用，这样一来，就可以调用子类中被重写的方法。但是向上转型并不能调用子类特有属性和方法，例如上面代码中如果执行bird1.fly();将报错找不到方法。
看看啥是向下转型。

public class MyTest2 { 
    public static void main(String[] args) { 
    Animal bird1 = new Bird();//这里向上转型为Animal，并且指向子类的引用 bird1.eat();//小鸟吃的是虫子,eat是重写的方法 //bird1.fly();//fly方法是Bird类特有的方法，向上转型成Animal后不能调用，需要再向下转型，才能访问Bird类的特有属性方法 Bird bird2=(Bird) bird1;//向下转型。范围变小，需要强制转化 bird2.fly();//这时bird2已经是Bird类型，所以可以访问Bird中的特有属性和方法 } } class Monkey extends Animal { 
    void eat() { 
    System.out.println("猴子吃的是香蕉"); } } class Bird extends Animal { 
    void eat() { 
    System.out.println("小鸟吃的是虫子"); } void fly(){ 
    System.out.println("小鸟会飞"); } } abstract class Animal { 
    void eat() { 
    System.out.println("动物吃东西的方法"); } } 

1，访问子类重写方法，需要向上转型。 2，访问子类独有方法，需要先向上转型，而后向下转型 

因为我觉得Bird bird1=new Bird()这样新建对象后也能调用子类Bird的eat方法，为什么要使用多态，先创建父类实例，再指向子类，然后调用子类的重写方法呢？直接创建子类的实例，然后调用子类的方法不是也很方便嘛？
然后要访问子类的特有方法，使用多态更麻烦，需要先向上转型，然后再向下转型。
完全没有直接实例化子类来得方便呀？
这个不理解，等我理解了再来改。

9，抽象类

抽象类就是足够抽象的类，他不能直接被实例化，而只能被继承使用。一个类只能继承一个抽象类，而一个类却可以实现多个接口。

public class MyTest2 { 
    public static void main(String[] args) { 
    Bird bird1 = new Bird(); bird1.fly(); } } class Bird extends Animal { 
    void eat() { 
    System.out.println("小鸟吃的是虫子"); } void fly(){ 
    System.out.println("小鸟会飞"); } } abstract class Animal { 
    void eat() { 
    System.out.println("动物吃东西的方法"); } } 

而当抽象类有抽象方法时，需要子类继承时，重写抽象方法。

public class MyTest2 { 
    public static void main(String[] args) { 
    Bird bird1 = new Bird(); bird1.fly(); } } class Bird extends Animal { 
    void eat() { 
    System.out.println("小鸟吃的是虫子"); } void fly(){ 
    System.out.println("小鸟会飞"); } //抽象类被继承后，抽象方法需要被重写 public void computePay(){ 
    System.out.println("抽象方法的实现"); } } abstract class Animal { 
    void eat() { 
    System.out.println("动物吃东西的方法"); } //抽象类定义抽象方法 public abstract void computePay(); } 

于是抽象类：

1. 抽象类不能被实例化，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。 2. 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。 3. 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。 4. 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。 5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。 

10，封装

封装的实现就是：对内聚合保护，对外解耦提供接口

public class MyTest2 { 
    public static void main(String[] args) { 
    Person test=new Person(); test.setName("小明"); System.out.println("名字是"+test.getName()); } } class Person{ 
    private String name; public String getName(){ 
    return name; } public void setName(String name){ 
    this.name = name; } } 

这里的name就被保护在类中，类外无法直接访问和修改，只能通过该类对外提供的方法才能访问和修改。

11，接口

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。
接口不是被类继承了，而是要被类实现。
实例：

public class MyTest2 { 
    public static void main(String[] args) { 
    MammalInt test=new MammalInt(); test.eat(); } } //定义接口 interface Animal { 
    public void eat(); public void travel(); } //使用类实现接口 class MammalInt implements Animal{ 
    public void eat(){ 
    System.out.println("Mammal eats"); } public void travel(){ 
    System.out.println("Mammal travels"); } public int noOfLegs(){ 
    return 0; } } 

接口的继承

// 文件名: Sports.java public interface Sports { 
    public void setHomeTeam(String name); public void setVisitingTeam(String name); } // 文件名: Football.java public interface Football extends Sports { 
    public void homeTeamScored(int points); public void visitingTeamScored(int points); public void endOfQuarter(int quarter); } 

实现Football接口的类需要实现五个方法，其中两个来自于Sports接口。
接口的多继承
既然已经有抽象类了，为啥还要有接口呢？因为类只能单继承，而接口可以实现多继承，也就是可以继承多个父接口。

public interface Hockey extends Sports, Event 

七，java包

区分相同名称的类。 能够较好地管理大量的类。 控制访问范围。 

1，包的定义

Java 中使用 package 语句定义包，package 语句应该放在源文件的第一行，在每个源文件中只能有一个包定义语句，并且 package 语句适用于所有类型（类、接口、枚举和注释）的文件。

package 包名; 

2，包的使用

在src下新建一个package，然后无论是将原有的类拖进去还是新创建一个类，在这个类的最开始，都会定义这个类：

到此这篇java基础-（三）-java基础语法的文章就介绍到这了,更多相关内容请继续浏览下面的相关推荐文章，希望大家都能在编程的领域有一番成就！

版权声明：

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若内容造成侵权、违法违规、事实不符，请将相关资料发送至xkadmin@xkablog.com进行投诉反馈，一经查实，立即处理！

转载请注明出处，原文链接：https://www.xkablog.com/jjc/11025.html