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;
}//不同类型、非枚举类型,不能比较和赋值