c++转Java，自学
基本数据类型
基本数据类型是CPU可以直接进行运算的类型。Java定义了以下几种基本数据类型：
* 整数类型：byte，short，int，long
*浮点数类型：float，double
*字符类型：char
*布尔类型：boolean
| 占位符 | 说明 |
| %d | 格式化输出整数 |
| %x | 格式化输出十六进制整数 |
| %f | 格式化输出浮点数 |
| %e | 格式化输出科学计数法表示的浮点数 |
| %s | 格式化字符串 |
输入
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in); // 创建Scanner对象
System.out.print("Input your name: "); // 打印提示
String name = scanner.nextLine(); // 读取一行输入并获取字符串
System.out.print("Input your age: "); // 打印提示
int age = scanner.nextInt(); // 读取一行输入并获取整数
System.out.printf("Hi, %s, you are %d\n", name, age); // 格式化输出
}
}首先，我们通过import语句导入java.util.Scanner，import是导入某个类的语句，必须放到Java源代码的开头，后面我们在Java的package中会详细讲解如何使用import。
然后，创建Scanner对象并传入System.in。System.out代表标准输出流，而System.in代表标准输入流。直接使用System.in读取用户输入虽然是可以的，但需要更复杂的代码，而通过Scanner就可以简化后续的代码。
有了Scanner对象后，要读取用户输入的字符串，使用scanner.nextLine()，要读取用户输入的整数，使用scanner.nextInt()。Scanner会自动转换数据类型，因此不必手动转换。
数组定义
int[] ns = new int[5];
int[] ns = { 68, 79, 91, 85, 62 };
int[] ns;
ns = new int[] { 68, 79, 91, 85, 62 };
String[] names = {"ABC", "XYZ", "zoo"};
int[][] ns = {
{ 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
{ 9, 10, 11, 12 }
};可以用数组变量.length获取数组大小
public class Main {
public static void main(String[] args) {
int[] ns = { 1, 4, 9, 16, 25 };
for (int n : ns) {
System.out.println(n);
}
}
}和for循环相比，for each循环的变量n不再是计数器，而是直接对应到数组的每个元素。for each循环的写法也更简洁。但是，for each循环无法指定遍历顺序，也无法获取数组的索引。
System.out.println(Arrays.toString(ns));//输出数组
继承中super的用法
class Person{
public String name;
public String setName() {
name="xixi";
return name;
}
}
class Student extends Person{
public String setName(){
return super.setName();//调用父类的方法
}
final关键字
final关键字修饰类，这个类不可以被继承。
修饰方法，方法不能被重写。
修饰变量，变量为常量，只能被赋值一次。
final关键字修饰的其实是地址值，地址值无法被修改，但地址所指向的内容还是可以被修改的。
Java 重写(Override)与重载(Overload)
重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！
- 参数列表与被重写方法的参数列表必须完全相同。
- 返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。
- 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。
- 父类的成员方法只能被它的子类重写。
- 声明为 final 的方法不能被重写。
- 声明为 static 的方法不能被重写，但是能够被再次声明。
- 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
- 子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
- 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
- 构造方法不能被重写。
- 如果不能继承一个类，则不能重写该类的方法。
重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
- 被重载的方法必须改变参数列表(参数个数或类型不一样)；
- 被重载的方法可以改变返回类型；
- 被重载的方法可以改变访问修饰符；
- 被重载的方法可以声明新的或更广的检查异常；
- 方法能够在同一个类中或者在一个子类中被重载。
- 无法以返回值类型作为重载函数的区分标准。
抽象类 abstract
把一个方法声明为abstract，表示它是一个抽象方法，本身没有实现任何方法语句。因为这个抽象方法本身是无法执行的，所以，Person类也无法被实例化。编译器会告诉我们，无法编译Person类，因为它包含抽象方法。
abstract class Person {
public abstract void run();
}
引用别的包的类 import
// Person.java
package ming;
public class Person {
public void run() {
mr.jun.Arrays arrays = new mr.jun.Arrays();
}
}
//法二
// Person.javapackage ming;
// 导入完整类名:import mr.jun.Arrays;
public class Person {
public void run() {
Arrays arrays = new Arrays();
}
}
Final
- 用final修饰class可以阻止被继承：
- 用final修饰method可以阻止被子类覆写：
- 用final修饰field可以阻止被重新赋值：
- 用final修饰局部变量可以阻止被重新赋值：
内部类 定义在另一个类的内部，所以称为内部类（Nested Class）
public class Main {
public static void main(String[] args) {
//要实例化一个Inner，我们必须首先创建一个Outer的实例，然后，调用Outer实例的new来创建Inner实例：
Outer outer = new Outer("Nested"); // 实例化一个Outer
Outer.Inner inner = outer.new Inner(); // 实例化一个Inner
inner.hello();
}
}
class Outer {
private String name;
Outer(String name) {
this.name = name;
}
class Inner {
void hello() {
System.out.println("Hello, " + Outer.this.name);
}
}
}
Anonymous Class
还有一种定义Inner Class的方法，它不需要在Outer Class中明确地定义这个Class，而是在方法内部，通过匿名类（Anonymous Class）来定义。
class Outer {
private String name;
Outer(String name) {
this.name = name;
}
void asyncHello() {
Runnable r = new Runnable() {
@Override
public void run() {
System.out.println("Hello, " + Outer.this.name);
}
};
new Thread(r).start();
}Static Nested Class
用static修饰的内部类和Inner Class有很大的不同，它不再依附于Outer的实例，而是一个完全独立的类，因此无法引用Outer.this，但它可以访问Outer的private静态字段和静态方法。如果把StaticNested移到Outer之外，就失去了访问private的权限
public class Main {
public static void main(String[] args) {
Outer.StaticNested sn = new Outer.StaticNested();
sn.hello();
}
}
class Outer {
private static String NAME = "OUTER";
private String name;
Outer(String name) {
this.name = name;
}
static class StaticNested {
void hello() {
System.out.println("Hello, " + Outer.NAME);
}
}
}
String
String s1 = "Hello!";
String s2 = new String(new char[] {'H', 'e', 'l', 'l', 'o', '!'});
//Java字符串的一个重要特点就是字符串不可变。这种不可变性是通过内部的private final char[]字段，以及没有任何修改char[]的方法实现的。
两个字符串比较，必须总是使用equals()方法。//s1.equals(s2)
要忽略大小写比较，使用equalsIgnoreCase()方法。
"Hello".contains("ll"); // 是否包含子串:
//搜索子串
"Hello".indexOf("l"); // 2
"Hello".lastIndexOf("l"); // 3
"Hello".startsWith("He"); // true
"Hello".endsWith("lo"); // true
//提取子串
"Hello".substring(2); // "llo""Hello".substring(2, 4); "ll"Integer类
int i = 100;
// 通过new操作符创建Integer实例(不推荐使用,会有编译警告):
Integer n1 = new Integer(i);
public final class Integer {//integer源码
private final int value;
}//引用类型，如果要改变要修改其类型
| 方法 | 返回值 | 功能 |
| byteValue() | byte | 以 byte 类型返回该 Integer 的值 |
| shortValue() | short | 以 short 类型返回该 Integer 的值 |
| intValue() | int | 以 int 类型返回该 Integer 的值 |
| toString() | String | 返回一个表示该 Integer 值的 String 对象 |
| equals(Object obj) | boolean | 比较此对象与指定对象是否相等 |
| compareTo(Integer | int | 在数字上比较两个 Integer 对象，如相等，则返回 0； |
| valueOf(String s) | Integer | 返回保存指定的 String 值的 Integer 对象 |
| parseInt(String s) | int | 将数字字符串转换为 int 数值 |
枚举类 enum
Main{Weekday day = Weekday.TEST;
System.out.println(day);//day=TEST
int n = Weekday.MON.ordinal();//1，返回定义的常量的顺序
String s = Weekday.SUN.name(); // "SUN"，返回常量名
enum Weekday {//定义 声明
SUN, MON, TUE, WED, THU, FRI, SAT,TEST;
}//不同类型、非枚举类型，不能比较和赋值
976
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
