JAVA
Outside file: public |
输入：
方法一：从控制台接收一个字符，然后将其打印出来
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 |
Interface |
|
|
实例化 |
不能 |
不能 |
|
类 |
一种继承关系，一个类只能使用一次继承关系。可以通过继承多个接口实现多重继承 |
一个类可以实现多个interface |
|
数据成员 |
可有自己的 |
静态的不能被修改即必须是static final，一般不在此定义 |
|
方法 |
可以私有的，非abstract方法，必须实现 |
不可有私有的，默认是public，abstract 类型 |
|
变量 |
可有私有的，默认是friendly 型，其值可以在子类中重新定义，也可以重新赋值 |
不可有私有的，默认是public static final 型，且必须给其初值，实现类中不能重新定义，不能改变其值。 |
|
设计理念 |
表示的是“is-a”关系 |
表示的是“like-a”关系 |
|
实现 |
需要继承，要用extends |
要用implements |
声明方法的存在而不去实现它的类被叫做抽象类（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。
优质内容筛选与推荐>>
1、【Android手机测试】linux内存管理 -- 一个进程占多少内存？四种计算方法：VSS/RSS/PSS/USS
2、小学校
3、SQL随记(三)
4、B/S刷新C/S 程序的解决办法
5、js定时器setInterval()与setTimeout()区别、10秒自动跳转