文章目录
基本概念
命名规范
所有标识符都应该以 字母、$(美元符)、_(下划线) 开头
首字母之后可以是 字母、$、_ 或数字任何字符组合
关键字不能作为变量名或方法名
字节:
1B(byte)=8 bit 1024B=1KB
主要特性:
简单性 面对对象 可移植性 高性能 分布式 多态性 多线程 安全性 健壮性
逻辑运算符:
逻辑运算符 | 含义 | 说明 |
---|---|---|
&& | 与 | 两个都为1,结果为1 |
|| | 或 | 两个都为0,结果为0 |
^ | 异或 | 两个都相异为1 |
! | 取反 | 0变1,1变0 |
<< | 左移 | 高位丢弃,低位补0 |
>> | 右移 |
%和/的区别
包机制:
import java.util.; //通配符* 导入包下所有的类
输入:
Import java.utils.Scanner
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()){
System.out.println("scanner.nextInt()="+scanner.nextInt());
}
Scanner.close();
随机生成字母:
Random random = new Random();
char c = (char) (random.nextInt(26) + 65);
System.out.println("c = " + c);
语句:
switch 多选择结构
char grade = 'C';
switch (grade){
case 'A':
System.out.println("优秀");
break; //可选,跳出当前结构
……
default: //默认,以上值没匹配到
System.out.println("不及格");
break;
}
while循环
int i=0;
int sum=0;
while(i<100){ //计算1+2+3+...+100
i++;
sum+=i;
}
System.out.println(sum); //5050
do…while循环
//先执行后判断,至少执行一次
do{
i++;
sum+=i;
}while(i<100) //跟上面效果一样
for循环
//(初始化;条件判断;迭代)
for(int i=0;i<100;i++){
i++;
sum+=i;
}
foreach遍历
int [] numbers = {10,20,30,40,50}; //定义一个数组
for (int x:numbers){ //遍历数组或集合中的元素
System.out.println(x); //遍历数组的元素 10 20 30 40 50
}
数组的声明创建:
int[] nums=new int[3]; //int[] nums={1,2,3……}
nums[0]=1; //给数组元素赋值
nums[1]=2;
nums[3]=3;
for(int num:nums){ //foreach循环遍历
System.out.printIn(num);
}
int[] arr=new int[scanner.nextInt()]; //动态创建数组
for(int i=0;i<n;i++){
arr[i]=sc.nextInt();
}
数组的工具类
java.util.Arrays
方法 | 说明 |
---|---|
fill | 给数组赋值 |
sort | 升序 |
equals | 比较数组中元素是否相等 |
binarySearch | 对排序好的数组进行二分查找 |
Math 类的常用方法
import java.lang.Math;
方法 | 说明 |
---|---|
abs() | 计算绝对值:System.out.printIn(Math.abs(num)) |
sqrt() | 计算方根 |
ceil() | 向上取整 |
floor() | 向下取整 |
round() | 计算小数进行四舍五入 |
max() min() | 计算两个数的较大(小)值:System.out.printIn(Math.max(e,7)) |
random() | 大于0.0小于1…0的随机值 |
pow() | 计算指数函数的值 |
面向对象的三个特征:
继承 多态 封装
类和对象:
package sample;
public class StringTest{
private String s;
public void printString(){
System.out.println(s);
}
public void changeString(String str){
s = str;
}
public static void main(String[] args){
StringTest st = new StringTest(); //创建了一个StringTest类的对象st
st.changeString("Hello SZTU");
st.printString();
}
}
继承关系和构造方法调用
继承:继承是一种机制,允许一个类(子类或派生类)继承另一个类(父类或基类)的属性和方法。子类可以继承父类的特性,然后根据需要进行扩展、覆盖或重写。
注:Java中不支持类之间的多重继承,即不允许一个子类继承多个父类。
class Animal {
void makeSound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
void makeSound() {
super.makeSound(); // 调用父类的makeSound 方
System.out.println("Dog barks");
}
}
public class Test {
public static void main(String[] args) {
Dog myDog = new Dog();
myDog.makeSound();
}
}
super:可以在子类中调用父类的方法
继承特性和方法重写
package sample;
class Employee //基类
{
public String name; //名字
public int salary; //薪水
public static String getSalary(String name, int salary) {
String str;
str = "名字: " + name + " Salary: " + salary;
return str;
}
public static String getSalary2(String name, int salary) {
String str;
str = "名字: " + name + " Salary: " + salary;
return str;
}
}
public class TestExtend extends Employee //子类 {
public static void main(String[] args) {
//覆盖了从 Employee 类继承的同名方法
System.out.println("覆盖的方法调用:" + getSalary("王一",500));
System.out.println("继承的方法调用:" + getSalary2("王一",500));
System.out.println("覆盖的方法调用:" + getSalary("王飞",10000));
System.out.println(“继承的方法调用:” + getSalary2(“王飞",10000));
}
public static String getSalary(String name, int salary) {
String str;
if (salary>5000)
str = "名字: " + name + " Salary: " + salary;
else
str = "名字: " + name + " Salary:** **低于5000";
return str;
}
};
-
Employee 类是一个基类,包括了名字(name)和薪水(salary)的属性,以及两个静态方法 getSalary 和 getSalary2,用于返回员工的信息。
-
TestExtend 类是 Employee 类的子类,它继承了 Employee 类的属性和方法。
在 TestExtend 类中,定义了一个名为 getSalary 的新静态方法,它覆盖了从 Employee 类继承的同名方法,而 getSalary2 方法没有被覆盖。
- 在main方法中
getSalary(“王一”, 500) 调用的是 TestExtend 类中的 getSalary 方法,因为它覆盖了 Employee 类的同名方法。根据薪水的大小,它返回相应的员工信息。
getSalary2(“王一”, 500) 调用的是 Employee 类中的 getSalary2 方法,因为它没有被覆盖。它返回员工信息。
类的封装特性
class EncapTest {
int a; // 默认存取控制(default access)
public int b; //公有存取控制(public access)
private int c; //私有存取控制(private access)
//setc 和 getc,用于设定和获取私有变量 c 的值
// 访问c的方法
void setc(int i) {//设定c的值
c = i;
}
int getc() { //获得c的值
return c;
}
}
public class AccessTest {
public static void main(String args[]) {
EncapTest ob = new EncapTest();
// 以下代码是正确的
ob.a = 10;
ob.b = 20;
// 以下代码会产生错误
// ob.c = 30; 无法访问封装对象
// 我们必须通过公有的方法操作c
ob.setc(30); // 正确
System.out.println("a,b,and c: " + ob.a + " " +ob.b + " " + ob.getc())
}
}
c 具有私有存取控制,只能在 EncapTest 类内部访问,其他类无法直接访问它。
可以在 EncapTest 类内部定义两个方法:setc 和 getc,用于设定和获取私有变量 c 的值。
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
类的多态特性
多态性是指一个对象可以以不同的方式呈现,即相同的接口可以有多个不同的实现。多态性使得可以使用通用的接口来操作不同类型的对象,而无需关心具体对象的类型。多态性的实现通常涉及方法重载和方法重写,以及接口的使用
public class Test {
public Test() {}
public static void main(String[] args) {
Shape[] s= {
new Shape(1,4),
new Rectangle(1,2,3,4),
new Circle(2,3,5)};
for (Shape shape : s) { //实现多态
shape.draw();
}
}
}
class Shape{ //定义一个基类(Shape)
protected int x;
protected int y;
public Shape(){ }
public Shape(int x, int y){
this:当局部变量和成员变量同名时,可以使用 this 关键字来引用成员变量,以区分局部变量和成员变量
this.x = x;
this.y = y;
}
public void draw(){ System.out.println("This is a test in Shape."+x+y);
}
}
//创建派生类,继承基类(Rectangle和Circle)
class Rectangle extends Shape{
private int heigth;
private int weight;
public Rectangle(int x, int y, int w, int h){
super(x,y);
this.weight = w;
this.heigth = h;
}
public void draw(){ System.out.println("This is a test in Rectangle.+x+y+weight+heigth");}
}
class Circle extends Shape{
private int r;
public Circle(int x, int y, int r){
super(x,y);
this.r = r;
}
public void draw(){System.out.println("This is a test in Circle."+x+y+r);}
}
语法
实例变量和静态变量
静态变量是在所有对象实例之间共享的,因此无论使用哪个对象实例来访问静态变量,它们都会访问到相同的静态变量。
实例变量是每个对象实例独有的,所以不同对象实例的实例变量可以有不同的值。
class Example05_1 {
int a = 1;
static int b = 2; b为静态变量
}
class Test {
public static void main(String args[]) {
System.out.println("b=" + Example05_1.b);
Example05_1.b*= 2; b=4
Example05_1 o1 = new Example05_1 ();
o1.a = 10;
System.out.println("o1.a="+ o1.a); a=10
System.out.println("b="+ o1.b);
Example05_1 o2=new Example05_1 ();
System.out.println("o2.a=" + o2.a);
System.out.println("b="+ o2.b);
}
}
静态变量(b)通过类名(Example05_1.b)来访问,而实例变量(a)通过对象实例(o1.a和o2.a)来访问。
Integer与int的区别:
Integer的初始值是null
int的初始值是0
Integer存储在堆内存
int类型是直接存储在栈空间
Integer是对象类型,它封装了很多的方法和属性,我们在使用的时候更加灵活。
自动装箱和拆箱
装箱:将基本数据类型,封装成包装类型的对象,这个过程就是装箱
Integer in=new Integer()
拆箱:从包装类型的对象中,将其包装的基本类型的数据取出,这个过程就是拆箱
Int i=in.intValue();
自动装箱:可以直接使用基本类型的数据,给引用类型的变量赋值
Integer A=3;
自动拆箱:可以直接使用包装类对象,给基本类型的变量赋值
Int a=A;
Java中有哪些基本数据类型以及其对应的包装类?
byte:Byte
short:Short
int:Integer
long:Long
float:Float
double:Double
char:Character
boolean:Boolean
枚举
用enum关键字来声明枚举,然后就可以直接定义枚举值
enum Day {
MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}
public class EnumTest {
public static void main(String[] args) {
// 创建枚举数组
Day[] days = new Day[] { Day.MONDAY, Day.TUESDAY, Day.WEDNESDAY,
Day.THURSDAY, Day.FRIDAY, Day.SATURDAY, Day.SUNDAY };
// 打印枚举常量的序号以及枚举值
for (int i = 0; i < days.length; i++) {
System.out.println("day[" + days[i].ordinal() + "]:"+ days[i].name());
}
// 通过compareTo方法比较,实际上其内部是通过ordinal()值比较的
System.out.println("day[1] VS day[2]:" + days[1].compareTo(days[2]));
}
}
枚举类的常量具有哪些方法?
name():返回枚举常量的名称。
ordinal():返回枚举常量的序号,从0开始计数。
compareTo():比较枚举常量的顺序,返回值为负表示当前枚举常量在参数枚举常量之前,返回值为正表示在其后,返回值为0表示相等。
values():返回一个包含所有枚举常量的数组。
注释和注解
1. 注释:
来给代码添加说明和解释的文本,它对程序的编译和执行没有任何影响
2. 注解:
注解可以用来声明、配置和使用,可以对类、方法、字段等进行注解。注解可以在运行时被读取和处理,可以通过反射机制获取注解信息。通常使用@Override和@Deprecated注解,
@Override: 表示正确的覆盖操作。
@Deprecated: 表示不建议使用的操作;
@SuppressWarnings:压制警告
@Override
public void someMethod() {
// 重写父类的方法
}
@Deprecated
public void oldMethod() {
// 这个方法已经被弃用
}
函数式接口
Lambda表达式
形参列表:指定Lambda表达式的参数列表。可以包含零个或多个参数,并用括号括起来。
例如:(a, b) -> {…}
箭头符号:由->组成,用于将参数列表与Lambda表达式的主体分隔开。
Lambda表达式的主体:包含具体的执行逻辑。可以是一个表达式或一段代码块。
例如:a + b或{ System.out.println(“Hello”); }
interface Drawable{
public void draw();
}
public class Hello {
public static void main(String[] args) {
int width = 10;
// with lambda expression
Drawable d = () -> {
System.out.println("Drawing " + width);
};
d.draw();
}
}
字符串的截取和定位
在 Java 中,字符串的截取和定位可以通过使用 substring() 方法和 indexOf() 方法来实现。
substring() 方法:用于从原始字符串中截取子串。它有两个重载的形式:
substring(int beginIndex): 从指定的 beginIndex 开始截取到字符串的末尾。
substring(int beginIndex, int endIndex): 从指定的 beginIndex 开始截取到 endIndex - 1 处的字符。**
class SubStringExample{
public static void main(String[] args) {
String s="hello Java语言";
int n1=s.indexOf('a');
int n2=s.indexOf("a语");
System.out.println("n1="+n1+" n2="+n2);
char c=s.charAt(2);
String s1=s.substring(6,10);
String s2=s.substring(4,7);
System.out.println("c="+c+" s1="+s1+" s2="+s2);
}
}
使用String类的public String concat(String str)方法可以把调用该方法的字符串与参数指定的字符串连接
抛出异常
throw关键字
throw 是一个关键字,用于手动抛出异常。当程序中发生某些不符合预期的情况时,可以使用 throw 语句显式地抛出异常对象。throw 语句通常与 try-catch 块结合使用,以便在发生异常时捕获并处理它。
throw new FileNotFoundException("File not found");
ArithmeticException :
是 Java 中的一个运行时异常类,继承自 RuntimeException。
它通常在数学运算出现错误的情况下被抛出。最常见的情况是除法运算时除数为零,但也可能发生其他导致算术运算错误的情况。
class Test {
static int method(int x, int y) {
if (x < y)
throw new ArithmeticException("x<y");
return x - y;
}
public static void main(String[] args) {
try {
int result1 = method(5, 10); // 触发异常,因为5 < 10
System.out.println("Result 1: " + result1);
} catch (ArithmeticException e) {
System.out.println("Exception caught: " + e.getMessage());
}
}
}