输入：

方法一：从控制台接收一个字符，然后将其打印出来

　　public static void main(String [] args) throws IOException{

　　System.out.print(“Enter a Char:”);

　　char i = (char) System.in.read();

　　System.out.println(“your char is :”+i);

　　}

　　}

方法二：这种方法我认为是最简单，最强大的，就是用Scanner类

　　public static void main(String [] args) {

　　Scanner sc = new Scanner(System.in);

　　System.out.println(“请输入你的姓名：”);

　　String name = sc.nextLine();

　　System.out.println(“请输入你的年龄：”);

　　int age = sc.nextInt();

　　System.out.println(“请输入你的工资：”);

　　float salary = sc.nextFloat();

　　System.out.println(“你的信息如下：”);

　　System.out.println(“姓名：”+name+“\n”+“年龄：”+age+“\n”+“工资：”+salary);

　　}

数组的建立:

int javaArray[];

javaArray=new int[10];

对象的建立：

Obj obj1=new Obj();

java继承：（extends）

public class B extends A

{

}

IS-A关系（继承关系）就是说:一个对象是另一个对象的一个分类。

通过使用关键字extends，子类可以继承父类所有的方法和属性，但是无法使用 private(私有) 的方法和属性.

package oo;

class animal

{

   publicvoid move()

   {

       System.out.println("动物可以移动");

   }

}

class Dog extends animal

{

   publicvoid move()

   {

       System.out.println("狗可以跑和走");

       System.out.println("狗可以吠叫");

   }

}

publicclass TestDog

{

 publicstaticvoid main(String []args)

 {

    animal a=new animal();

    animal b=new Dog();

    a.move();

    b.move();

 }

}

instanceof 操作符能够确定两者是否有is-A关系

Implements关键字使用在类继承接口的情况下， 这种情况不能使用关键字extends。

public interface Animal{}

public class Mammal implements Animal{}

public class Dog extends Mammal{}

HAS-A关系（从属关系）：

public class Vehicle{}

public class Speed{}

public class Van extends Vehicle{

private Speed sp;}

一个类不能继承多个类。

错误：public class Dog extends Animal,Mammal{}

但是可以用接口来实现（多继承接口）

public class Apple extends Fruit implement Fruit1,Fruit2{}

extends 是继承某个类, 继承之后可以使用父类的方法, 也可以重写父类的方法; implements 是实现多个接口, 接口的方法一般为空的, 必须重写才能使用

extends是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承，JAVA中不支持多重继承，但是可以用接口来实现，这样就要用到implements，继承只能继承一个类，但implements可以实现多个接口，用逗号分开就行了

重载：

package oo;

publicclass Overloading {

   publicint test() {

       System.out.println("test1");

       return 1;

   }

   publicvoid test(inta) {

       System.out.println("test2");

   }

   public String test(inta, String b) {

       System.out.println("test3");

        return"returntest3";

   }

   public String test(String a,intb)

   {

       System.out.println("test4");

       return"returntest4";

   }

   publicstaticvoid  main(String[]args)

   {

      Overloading o=new Overloading();

      System.out.println(o.test());

      o.test(1);

      System.out.println(o.test(1,"test3"));

      System.out.println(o.test("test4",1));

   }

}

implements是一个类实现一个接口用的关键字，是用来实现接口中定义的抽象方法。

比如：people是一个接口，里面有say这个方法。
public interface people(){ public say();}但是接口没有方法体。
只能通过一个具体的类去实现其中的方法体。
比如chinese这个类，就实现了people这个接口。
 public class chinese implements people{public say() {System.out.println("你好！");}}
 在java中implements表示子类继承父类，如类A继承类B写成 class A implements B{}
与extends不同， 可以实现父类，也可以调用父类初始化this.parent()。
而且会覆盖父类定义的变量或者函数。

比如说，你把文件命名成“cat.java”   那这个文件中的类cat 必须是用public 修饰的,而且除了这个cat 前面可以用public修饰其他类不能用public修饰  

例子：
文件名：cat.java
文件中写法：
public class cat{

}
class dog{
}
class pig{
}下面2个叫内部类，内部类在高级编程中会用来做驱动等

同一个package中的类是可以有自己的main方法的，方法的名字必须是main，方法必须是public static void 类型的，方法必须接收一个字符串数组的参数。

而且类与类之间的main方法也是可以相互调用的。main方法是程序的入口，而且内部类也是可以有main方法的，但是前提是这个内部类必须是static修饰的。

你可以让你的代码有多个入口，你只需要明白你什么时候要用哪个类作为入口就可以了，

但是要注意的是，用不同入口启动的两个进程是毫不相关的，

Java中的ArrayList:

1.依次按顺序添加数据

list1.add(“a”);

2.在第n个数据之后添加一个数据

list1.add(1,”E”);

3.将一个ArrayList中的所有数据添加到另外一个ArrayList中：

list1.addAll(list2);

4.将一个ArrayList中的所有数据添加到另外一个ArraList中的第N个元素之后

list1.addAll(2,list2)

5. 按照位置删除单个数据

将list中的第二个数据删除

list.remove(2);

6.按照内容删除数据

删除数据“d”

list.remove(“d”);

7.按照集合同时删除多个数据

按照list2中的数据来删除list1

list1.removeAll(list2);

在Java语言中，abstract class和interface是支持抽象类定义的两种机制。正是由于这两种机制的存在，才赋予了Java强大的面向对象能力。

声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。

接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现 这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。 然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到 接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。

1.相同点
  A. 两者都是抽象类，都不能实例化。
  B. interface实现类及abstrct class的子类都必须要实现已经声明的抽象方法。

2. 不同点
  A. interface需要实现，要用implements，而abstract class需要继承，要用extends。
  B. 一个类可以实现多个interface，但一个类只能继承一个abstract class。

JAVA