javase学习——面向对象(下)
1. 静态
1.1 静态关键字(Static)
- 在类中声明的实例变量,其值是每一个对象独立的。但是有些成员变量的值不需要或不能每一个对象单独存储一份,即有些成员变量和当前类的对象无关。
- 在类中声明的实例方法,在类的外面必须要先创建对象,才能调用。但是有些方法的调用和当前类的对象无关,那么创建对象就有点麻烦了。
- 此时,就需要将和当前类的对象无关的成员变量、成员方法声明为静态的(static)。
1.2 语法格式
【修饰符】 class 类{【其他修饰符】 static 数据类型 静态变量名;
}
1.3 静态变量的特点
- 静态变量的默认值规则和实例变量一样。
- 静态变量值是所有对象共享。
- 静态变量的值存储在方法区。
- 静态变量在本类中,可以在任意方法、代码块、构造器中直接使用。
- 如果权限修饰符允许,在其他类中可以通过“类名.静态变量”直接访问,也可以通过“对象.静态变量”的方式访问(但是更推荐使用类名.静态变量的方式)。
- 静态变量的get/set方法也静态的,当局部变量与静态变量重名时,使用“类名.静态变量”进行区分。
1.4 静态变量、非静态变量、局部变量
- 静态类变量(简称静态变量):存储在方法区,有默认值,所有对象共享,生命周期和类相同,还可以有权限修饰符、final等其他修饰符
- 非静态实例变量(简称实例变量):存储在堆中,有默认值,每一个对象独立,生命周期每一个对象也独立,还可以有权限修饰符、final等其他修饰符
- 局部变量:存储在栈中,没有默认值,每一次方法调用都是独立的,有作用域,只能有final修饰,没有其他修饰符
1.5 静态方法
【修饰符】 class 类{【其他修饰符】 static 返回值类型 方法名(形参列表){方法体}
}
1.6 静态方法的特点
- 静态方法在本类的任意方法、代码块、构造器中都可以直接被调用。
- 只要权限修饰符允许,静态方法在其他类中可以通过“类名.静态方法“的方式调用。也可以通过”对象.静态方法“的方式调用(但是更推荐使用类名.静态方法的方式)。
- 静态方法可以被子类继承,但不能被子类重写。
- 静态方法的调用都只看编译时类型。
1.7 静态代码块
【修饰符】 class 类{static{静态代码块}
}
1.8 静态代码块的特点
每一个类的静态代码块只会执行一次。
静态代码块的执行优先于非静态代码块和构造器。
1.9 静态代码块和非静态代码块
静态代码块在类初始化时执行,只执行一次
非静态代码块在实例初始化时执行,每次new对象都会执行
2. 枚举类
2.1 JDK1.5之前
- 构造器加private私有化
- 本类内部创建一组常量对象,并添加public static final修饰符,对外暴露这些常量对象
public class Season{public static final Season SPRING = new Season();public static final Season SUMMER = new Season();public static final Season AUTUMN = new Season();public static final Season WINTER = new Season();private Season(){}public String toString(){if(this == SPRING){return "春";}else if(this == SUMMER){return "夏";}else if(this == AUTUMN){return "秋";}else{return "冬";}}
}
2.2 JDK1.5之后
2.2.1 借助于enum关键字
【修饰符】 enum 枚举类名{常量对象列表
}【修饰符】 enum 枚举类名{常量对象列表;其他成员列表;
}
public enum Week {MONDAY("星期一"),TUESDAY("星期二"),WEDNESDAY("星期三"),THURSDAY("星期四"),FRIDAY("星期五"),SATURDAY("星期六"),SUNDAY("星期日");private final String description;private Week(String description){this.description = description;}@Overridepublic String toString() {return super.toString() +":"+ description;}
}
2.2.2 枚举类的特点
- 枚举类的常量对象列表必须在枚举类的首行,因为是常量,所以建议大写。
- 如果常量对象列表后面没有其他代码,那么“;”可以省略,否则不可以省略“;”。
- 编译器给枚举类默认提供的是private的无参构造,如果枚举类需要的是无参构造,就不需要声明,写常量对象列表时也不用加参数,
- 如果枚举类需要的是有参构造,需要手动定义,有参构造的private可以省略,调用有参构造的方法就是在常量对象名后面加(实参列表)就可以。
- 枚举类默认继承的是java.lang.Enum类,因此不能再继承其他的类型。
- JDK1.5之后switch,提供支持枚举类型,case后面可以写枚举常量名。
- 枚举类型如有其它属性,建议(不是必须)这些属性也声明为final的,因为常量对象在逻辑意义上应该不可变。
2.3 枚举类常用方法
1.String toString(): 默认返回的是常量名(对象名),可以继续手动重写该方法!
2.String name():返回的是常量名(对象名)
3.int ordinal():返回常量的次序号,默认从0开始
4.枚举类型[] values():返回该枚举类的所有的常量对象,返回类型是当前枚举的数组类型,是一个静态方法
5.枚举类型 valueOf(String name):根据枚举常量对象名称获取枚举对象
3. 包装类
基本数据类型 | 包装类 |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
char | Character |
boolean | Boolean |
void | Void |
3.1 装箱与拆箱
装箱:把基本数据类型转为包装类对象。
转为包装类的对象,是为了使用专门为对象设计的API和特性
拆箱:把包装类对象拆为基本数据类型。
转为基本数据类型,一般是因为需要运算,Java中的大多数运算符是为基本数据类型设计的。比较、算术等
3.2 基本数据类型和字符串之间的转换
3.2.1 基本数据类型转换为字符串
int a = 10;
//String str = a;//错误的
//方式一:
String str = a + "";
//方式二:
String str = String.valueOf(a);
3.2.2 字符串转换为基本数据类型
String转换成对应的基本类型 ,除了Character类之外,其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型,例如:
public static int parseInt(String s)
:将字符串参数转换为对应的int基本类型。public static long parseLong(String s)
:将字符串参数转换为对应的long基本类型。public static double parseDouble(String s)
:将字符串参数转换为对应的double基本类型。
或把字符串转为包装类,然后可以自动拆箱为基本数据类型
public static Integer valueOf(String s)
:将字符串参数转换为对应的Integer包装类,然后可以自动拆箱为int基本类型public static Long valueOf(String s)
:将字符串参数转换为对应的Long包装类,然后可以自动拆箱为long基本类型public static Double valueOf(String s)
:将字符串参数转换为对应的Double包装类,然后可以自动拆箱为double基本类型
int a = Integer.parseInt("整数的字符串");
double d = Double.parseDouble("小数的字符串");
boolean b = Boolean.parseBoolean("true或false");int a = Integer.valueOf("整数的字符串");
double d = Double.valueOf("小数的字符串");
boolean b = Boolean.valueOf("true或false");
3.2.3 数据类型的最小值和最大值
Integer.MAX_VALUE和Integer.MIN_VALUE
Long.MAX_VALUE和Long.MIN_VALUE
Double.MAX_VALUE和Double.MIN_VALUE
3.2.4 字符转大小写
Character.toUpperCase('x');
Character.toLowerCase('X');
3.2.5 比较的方法
Double.compare(double d1, double d2)
Integer.compare(int x, int y)
4. 抽象类
抽象:即不具体、或无法具体
例如:当我们声明一个几何图形类:圆、矩形、三角形类等,发现这些类都有共同特征:求面积、求周长、获取图形详细信息。那么这些共同特征应该抽取到一个公共父类中。但是这些方法在父类中又无法给出具体的实现,而是应该交给子类各自具体实现。那么父类在声明这些方法时,就只有方法签名,没有方法体,我们把没有方法体的方法称为抽象方法。Java语法规定,包含抽象方法的类必须是抽象类。
4.1 抽象方法和抽象类的语法格式
- 抽象方法:被abstract修饰没有方法体的方法。
- 抽象类:被abstract修饰的类。
【权限修饰符】 abstract class 类名{}
【权限修饰符】 abstract class 类名 extends 父类{}【其他修饰符】 abstract 返回值类型 方法名(【形参列表】);
4.2 注意事项
抽象类不能创建对象,如果创建,编译无法通过而报错。只能创建其非抽象子类的对象。
理解:假设创建了抽象类的对象,调用抽象的方法,而抽象方法没有具体的方法体,没有意义。
抽象类中,也有构造方法,是供子类创建对象时,初始化父类成员变量使用的。
理解:子类的构造方法中,有默认的super()或手动的super(实参列表),需要访问父类构造方法。
抽象类中,不一定包含抽象方法,但是有抽象方法的类必定是抽象类。
理解:未包含抽象方法的抽象类,目的就是不想让调用者创建该类对象,通常用于某些特殊的类结构设计。
抽象类的子类,必须重写抽象父类中所有的抽象方法,否则,编译无法通过而报错。除非该子类也是抽象类。
理解:假设不重写所有抽象方法,则类中可能包含抽象方法。那么创建对象后,调用抽象的方法,没有意义。
4.3 不能abstract一起使用的修饰符
(1)abstract和final不能一起修饰方法和类
(2)abstract和static不能一起修饰方法
(3)abstract和native不能一起修饰方法
(4)abstract和private不能一起修饰方法
5. 接口
接口的定义,它与定义类方式相似,但是使用 interface
关键字。它也会被编译成.class文件,但一定要明确它并不是类,而是另外一种引用数据类型。
引用数据类型:数组,类,枚举,接口,注解。
5.1 接口的格式声明
【修饰符】 interface 接口名{//接口的成员列表:// 公共的静态常量// 公共的抽象方法// 公共的默认方法(JDK1.8以上)// 公共的静态方法(JDK1.8以上)// 私有方法(JDK1.9以上)
}
public interface Usb3{//静态常量long MAX_SPEED = 500*1024*1024;//500MB/s//抽象方法void in();void out();//默认方法default void start(){System.out.println("开始");}default void stop(){System.out.println("结束");}//静态方法static void show(){System.out.println("USB 3.0可以同步全速地进行读写操作");}
}
5.2 接口相关面试题
1、为什么接口中只能声明公共的静态的常量?
因为接口是标准规范,那么在规范中需要声明一些底线边界值,当实现者在实现这些规范时,不能去随意修改和触碰这些底线,否则就有“危险”。
例如:USB1.0规范中规定最大传输速率是1.5Mbps,最大输出电流是5V/500mA
USB3.0规范中规定最大传输速率是5Gbps(500MB/s),最大输出电流是5V/900mA
例如:尚硅谷学生行为规范中规定学员,早上8:25之前进班,晚上21:30之后离开等等。
2、为什么JDK1.8之后要允许接口定义静态方法和默认方法呢?因为它违反了接口作为一个抽象标准定义的概念。
静态方法:因为之前的标准类库设计中,有很多Collection/Colletions或者Path/Paths这样成对的接口和类,后面的类中都是静态方法,而这些静态方法都是为前面的接口服务的,那么这样设计一对API,不如把静态方法直接定义到接口中使用和维护更方便。
默认方法:(1)我们要在已有的老版接口中提供新方法时,如果添加抽象方法,就会涉及到原来使用这些接口的类就会有问题,那么为了保持与旧版本代码的兼容性,只能允许在接口中定义默认方法实现。比如:Java8中对Collection、List、Comparator等接口提供了丰富的默认方法。(2)当我们接口的某个抽象方法,在很多实现类中的实现代码是一样的,此时将这个抽象方法设计为默认方法更为合适,那么实现类就可以选择重写,也可以选择不重写。
3、为什么JDK1.9要允许接口定义私有方法呢?因为我们说接口是规范,规范时需要公开让大家遵守的
私有方法:因为有了默认方法和静态方法这样具有具体实现的方法,那么就可能出现多个方法由共同的代码可以抽取,而这些共同的代码抽取出来的方法又只希望在接口内部使用,所以就增加了私有方法。
5.3 接口总结
- 接口本身不能创建对象,只能创建接口的实现类对象,接口类型的变量可以与实现类对象构成多态引用。
- 声明接口用interface,接口的成员声明有限制:(1)公共的静态常量(2)公共的抽象方法(3)公共的默认方法(4)公共的静态方法(5)私有方法(JDK1.9以上)
- 类可以实现接口,关键字是implements,而且支持多实现。如果实现类不是抽象类,就必须实现接口中所有的抽象方法。如果实现类既要继承父类又要实现父接口,那么继承(extends)在前,实现(implements)在后。
- 接口可以继承接口,关键字是extends,而且支持多继承。
- 接口的默认方法可以选择重写或不重写。如果有冲突问题,另行处理。子类重写父接口的默认方法,要去掉default,子接口重写父接口的默认方法,不要去掉default。
- 接口的静态方法不能被继承,也不能被重写。接口的静态方法只能通过“接口名.静态方法名”进行调用。
5.4 四大经典接口
1.java.lang.Comparable
第一步:哪个类的对象要比较大小,哪个类就实现java.lang.Comparable接口,并重写方法
- 方法体就是你要如何比较当前对象和指定的另一个对象的大小
第二步:对象比较大小时,通过对象调用compareTo方法,根据方法的返回值决定谁大谁小。
- this对象(调用compareTo方法的对象)大于指定对象(传入compareTo()的参数对象)返回正整数
- this对象(调用compareTo方法的对象)小于指定对象(传入compareTo()的参数对象)返回负整数
- this对象(调用compareTo方法的对象)等于指定对象(传入compareTo()的参数对象)返回零
public class Student implements Comparable {private int id;private String name;private int score;private int age;public Student(int id, String name, int score, int age) {this.id = id;this.name = name;this.score = score;this.age = age;}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getScore() {return score;}public void setScore(int score) {this.score = score;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Student{" +"id=" + id +", name='" + name + '\'' +", score=" + score +", age=" + age +'}';}@Overridepublic int compareTo(Object o) {//这些需要强制,将o对象向下转型为Student类型的变量,才能调用Student类中的属性//默认按照学号比较大小Student stu = (Student) o;return this.id - stu.id;}
}
2.java.util.Comparator
第一步:编写一个类,我们称之为比较器类型,实现java.util.Comparator接口,并重写方法
- 方法体就是你要如何指定的两个对象的大小
第二步:比较大小时,通过比较器类型的对象调用compare()方法,将要比较大小的两个对象作为compare方法的实参传入,根据方法的返回值决定谁大谁小。
- o1对象大于o2返回正整数
- o1对象小于o2返回负整数
- o1对象等于o2返回零
import java.util.Comparator;public class StudentScoreComparator implements Comparator {@Overridepublic int compare(Object o1, Object o2) {Student s1 = (Student) o1;Student s2 = (Student) o2;int result = s1.getScore() - s2.getScore();return result != 0 ? result : s1.getId() - s2.getId();}
}
3.java.lang.Cloneable
所有类型都可以重写这个方法,它是获取一个对象的克隆体对象用的,就是造一个和当前对象各种属性值一模一样的对象。当然地址肯定不同。
我们在重写这个方法后时,调用super.clone(),发现报异常CloneNotSupportedException,因为我们没有实现java.lang.Cloneable接口。
class Teacher implements Cloneable{private int id;private String name;public Teacher(int id, String name) {super();this.id = id;this.name = name;}public Teacher() {super();}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Teacher [id=" + id + ", name=" + name + "]";}@Overridepublic Object clone() throws CloneNotSupportedException {return super.clone();}@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + id;result = prime * result + ((name == null) ? 0 : name.hashCode());return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;Teacher other = (Teacher) obj;if (id != other.id)return false;if (name == null) {if (other.name != null)return false;} else if (!name.equals(other.name))return false;return true;}
}
4.java.lang.Iterable接口
语法格式:
for(元素类型 元素名 : 数组名){
}
public class TestForeach {public static void main(String[] args) {int[] nums = {1,2,3,4,5};for (int num : nums) {System.out.println(num);}System.out.println("-----------------");String[] names = {"张三","李四","王五"};for (String name : names) {System.out.println(name);}}
}
6. 内部类
1、什么是内部类?
将一个类A定义在另一个类B里面,里面的那个类A就称为内部类,B则称为外部类。
2、为什么要声明内部类呢?
总的来说,遵循高内聚低耦合的面向对象开发总原则。便于代码维护和扩展。
具体来说,当一个事物的内部,还有一个部分需要一个完整的结构进行描述,而这个内部的完整的结构又只为外部事物提供服务,不在其他地方单独使用,那么整个内部的完整结构最好使用内部类。而且内部类因为在外部类的里面,因此可以直接访问外部类的私有成员。
3、内部类都有哪些形式?
根据内部类声明的位置(如同变量的分类),我们可以分为:
(1)成员内部类:
- 静态成员内部类
- 非静态成员内部类
(2)局部内部类
- 有名字的局部内部类
- 匿名的内部类
6.1 成员内部类
语法格式:
【修饰符】 class 外部类{【其他修饰符】 【static】 class 内部类{}
}
6.1.1 静态内部类
有static修饰的成员内部类叫做静态内部类。它的特点:
- 和其他类一样,它只是定义在外部类中的另一个完整的类结构
- 可以继承自己的想要继承的父类,实现自己想要实现的父接口们,和外部类的父类和父接口无关
- 可以在静态内部类中声明属性、方法、构造器等结构,包括静态成员
- 可以使用abstract修饰,因此它也可以被其他类继承
- 可以使用final修饰,表示不能被继承
- 编译后有自己的独立的字节码文件,只不过在内部类名前面冠以外部类名和$符号。
- 和外部类不同的是,它可以允许四种权限修饰符:public,protected,缺省,private
- 外部类只允许public或缺省的
- 只可以在静态内部类中使用外部类的静态成员
- 在静态内部类中不能使用外部类的非静态成员哦
- 如果在内部类中有变量与外部类的静态成员变量同名,可以使用“外部类名."进行区别
- 在外部类的外面不需要通过外部类的对象就可以创建静态内部类的对象(通常应该避免这样使用)
6.1.2 非静态内部类
没有static修饰的成员内部类叫做非静态内部类。非静态内部类的特点:
- 和其他类一样,它只是定义在外部类中的另一个完整的类结构
- 可以继承自己的想要继承的父类,实现自己想要实现的父接口们,和外部类的父类和父接口无关
- 可以在非静态内部类中声明属性、方法、构造器等结构,但是不允许声明静态成员,但是可以继承父类的静态成员,而且可以声明静态常量。
- 可以使用abstract修饰,因此它也可以被其他类继承
- 可以使用final修饰,表示不能被继承
- 编译后有自己的独立的字节码文件,只不过在内部类名前面冠以外部类名和$符号。
- 和外部类不同的是,它可以允许四种权限修饰符:public,protected,缺省,private
- 外部类只允许public或缺省的
- 还可以在非静态内部类中使用外部类的所有成员,哪怕是私有的
- 在外部类的静态成员中不可以使用非静态内部类哦
- 就如同静态方法中不能访问本类的非静态成员变量和非静态方法一样
- 在外部类的外面必须通过外部类的对象才能创建非静态内部类的对象(通常应该避免这样使用)
- 如果要在外部类的外面使用非静态内部类的对象,通常在外部类中提供一个方法来返回这个非静态内部类的对象比较合适
- 因此在非静态内部类的方法中有两个this对象,一个是外部类的this对象,一个是内部类的this对象
public class TestMemberInnerClass {public static void main(String[] args) {Outer.outMethod();System.out.println("-----------------------");Outer out = new Outer();out.outFun();System.out.println("####################################");Outer.Inner.inMethod();System.out.println("------------------------");Outer.Inner inner = new Outer.Inner();inner.inFun();System.out.println("####################################");Outer outer = new Outer();
// Outer.Nei nei = outer.new Nei();Outer.Nei nei = out.getNei();nei.inFun();}
}
class Outer{private static String a = "外部类的静态a";private static String b = "外部类的静态b";private String c = "外部类对象的非静态c";private String d = "外部类对象的非静态d";static class Inner{private static String a ="静态内部类的静态a";private String c = "静态内部类对象的非静态c";public static void inMethod(){System.out.println("Inner.inMethod");System.out.println("Outer.a = " + Outer.a);System.out.println("Inner.a = " + a);System.out.println("b = " + b);
// System.out.println("c = " + c);//不能访问外部类和自己的非静态成员
// System.out.println("d = " + d);//不能访问外部类的非静态成员}public void inFun(){System.out.println("Inner.inFun");System.out.println("Outer.a = " + Outer.a);System.out.println("Inner.a = " + a);System.out.println("b = " + b);System.out.println("c = " + c);
// System.out.println("d = " + d);//不能访问外部类的非静态成员}}class Nei{private String a = "非静态内部类对象的非静态a";private String c = "非静态内部类对象的非静态c";public void inFun(){System.out.println("Nei.inFun");System.out.println("Outer.a = " + Outer.a);System.out.println("a = " + a);System.out.println("b = " + b);System.out.println("Outer.c = " + Outer.this.c);System.out.println("c = " + c);System.out.println("d = " + d);}}public static void outMethod(){System.out.println("Outer.outMethod");System.out.println("a = " + a);System.out.println("Inner.a = " + Inner.a);System.out.println("b = " + b);
// System.out.println("c = " + c);
// System.out.println("d = " + d);Inner in = new Inner();System.out.println("in.c = " + in.c);}public void outFun(){System.out.println("Outer.outFun");System.out.println("a = " + a);System.out.println("Inner.a = " + Inner.a);System.out.println("b = " + b);System.out.println("c = " + c);System.out.println("d = " + d);Inner in = new Inner();System.out.println("in.c = " + in.c);}public Nei getNei(){return new Nei();}
}
6.2 局部内部类
语法格式:
【修饰符】 class 外部类{【修饰符】 返回值类型 方法名(【形参列表】){【final/abstract】 class 内部类{}}
}
局部内部类的特点:
- 和外部类一样,它只是定义在外部类的某个方法中的另一个完整的类结构
- 可以继承自己的想要继承的父类,实现自己想要实现的父接口们,和外部类的父类和父接口无关
- 可以在局部内部类中声明属性、方法、构造器等结构,但不包括静态成员,除非是从父类继承的或静态常量
- 可以使用abstract修饰,因此它也可以被同一个方法的在它后面的其他内部类继承
- 可以使用final修饰,表示不能被继承
- 编译后有自己的独立的字节码文件,只不过在内部类名前面冠以外部类名、$符号、编号。
- 这里有编号是因为同一个外部类中,不同的方法中存在相同名称的局部内部类
- 和成员内部类不同的是,它前面不能有权限修饰符等
- 局部内部类如同局部变量一样,有作用域
- 局部内部类中是否能访问外部类的非静态的成员,取决于所在的方法
- 局部内部类中还可以使用所在方法的局部常量,即用final声明的局部变量
- JDK1.8之后,如果某个局部变量在局部内部类中被使用了,自动加final
- 为什么在局部内部类中使用外部类方法的局部变量要加final呢?考虑生命周期问题。
6.3 匿名内部类
new 父类(【实参列表】){重写方法...
}
//()中是否需要【实参列表】,看你想要让这个匿名内部类调用父类的哪个构造器,如果调用父类的无参构造,那么()中就不用写参数,如果调用父类的有参构造,那么()中需要传入实参
new 父接口(){重写方法...
}
//()中没有参数,因为此时匿名内部类的父类是Object类,它只有一个无参构造
7. 注解
注解是以“@注释名”在代码中存在的,还可以添加一些参数值,例如:
@SuppressWarnings(value=”unchecked”)
@Override
@Deprecated
1、@Override
用于检测被标记的方法为有效的重写方法,如果不是,则报编译错误!
只能标记在方法上。
它会被编译器程序读取。
2、@Deprecated
用于表示被标记的数据已经过时,不建议使用。
可以用于修饰 属性、方法、构造、类、包、局部变量、参数。
它会被编译器程序读取。
3、@SuppressWarnings
抑制编译警告。
可以用于修饰类、属性、方法、构造、局部变量、参数
它会被编译器程序读取。
javase学习——面向对象(下)相关推荐
- JAVASE学习 面向对象
JAVASE学习 面向对象 1.面向对象(构造方法Constructor概述和格式) A:构造方法概述和作用 给对象的数据(属性)进行初始化 B:构造方法格式特点 a:方法名与类名相同(大小也要与类名 ...
- 【JavaSE】面向对象之多态、向上转型与向下转型
本专栏为 JavaSE 的学习笔记及相关项目,专栏长期免费更新 ❤️ ❤️ ❤️ ❤️ 个人主页:Nezuko627 欢迎来访~~~ ⭐️往期回顾: [JavaSE]继承中内存发生了什么变化?这篇文章 ...
- 【JavaSE学习】03面向对象Java语法
JavaSE(B站黑马)学习笔记 01Java入门 02数组.方法 03面向对象&Java语法 04-1Java高级(Stream流.异常处理.日志技术) 04-2Java高级(文件处理-IO ...
- JavaSE学习(1)
JavaSE学习(1)目录 单例模式 面向对象 继承extends 重载vs重写 构造函数 final关键字 抽象类abstract关键字 接口Interface 多态 匿名内部类 异常Excepti ...
- 【JavaSE学习笔记】
JavaSE学习笔记 一.java的基本语法 变量运算规则 编码情况1中l后面没有加L,默认是int变量 编码情况2中b1=b+1中的1默认是int型变量,会出错 string类型 string里面可 ...
- JavaSE学习笔记(持续更新)
这里写目录标题 JavaSE学习笔记(持续更新) Java跨平台原理与核心机制 1.跨平台原理: 2.两种核心机制: JDK11的安装流程 Java程序开发的三个步骤(无编辑器版) Eclipse安装 ...
- 重拾JavaSE学习笔记
重拾JavaSE学习笔记 1.常用DOS命令 2.了解Java 2.1 .java特性 2.2.JDK .JRE.JVM 2.3.java的加载和执行 3.开发环境搭建 3.1.安装jdk 3.2.配 ...
- 第四课 尚硅谷Scala语言学习-面向对象
第四课 尚硅谷Scala语言学习-面向对象 文章目录 第四课 尚硅谷Scala语言学习-面向对象 第一节 Scala 包 1.1 包基本语法 1.2 包说明 1.3 包对象 1.4 导包说明 第二节 ...
- JavaSE学习总结(八)常用类(上)Object类==与equals方法的区别浅克隆的特点Scanner类String类String两种创建对象方式的区别String类的各种功能
JavaSE学习总结(八)常用类(上)/Object类/==与equals方法的区别/浅克隆的特点/Scanner类/String类/String两种创建对象方式的区别/String类的各种功能 常用 ...
- JavaSE学习小结二
JavaSE学习小结二 记录学习----------JavaSE模块三&四 其中大部分是一些工具类,会将常用方法及其功能描述整理成表格方便日后查阅 文章目录 JavaSE学习小结二 一.Obj ...
最新文章
- 使用php与mysql构建我们的网站
- 在线协作开发工具apizza使用方法(https://apizza.net/projects)
- php curl hostname,php – 如何解决cURL错误(7):无法连接到主机?
- ejb 2.0 3.0_EJB 3.0注入和查找简介
- SpringBoot工程不注册到Eureka上
- 算法(四)、时间复杂度、排序、查找
- 设计一个序列信号发生器, 产生序列信号1011101. 用74LS161和4选1数据选择器74153及必要的门电路实现
- 解决U盘复制拷贝文件过大不能超过4G的方法
- html怎样让线段显示长度,CAD想要知道线段的长度有什么技巧吗?
- nginx 代理ip 和域名
- 3G、4G移动数据网络业务流程
- 不义联盟2显示服务器,打开不义联盟2提示网络异常或者连接不上
- python陆股通_要闻:11月“陆股通”渠道外资净买入A股579亿元
- 2022-2028年全球与中国全轮驱动(AWD)系统行业深度分析
- 第五届传智杯-初赛【B组-题解】
- 一篇搞懂 IP、子网掩码、网关、DNS、端口号
- 2021软考数据库工程师复习笔记记录
- 支持中文首拼 快速查询的电话本(blackberry)
- minio存储之纠删码(Erasure Code)
- Android逆向移花接木之添加AlertDialog
热门文章
- 计算机安全模式无法启动,电脑安全模式启动不了怎么办
- 计算机总是说该程序正在使用,另一个程序正在使用此文件,电脑程序正在使用此文件无法访问如何解决...
- CAD填充块Hatch的深度解析
- Lamp部署于三台主机中
- ICCMO微信公众账号开发系列(1)接入微信公众账号
- 微信公众账号调取用户昵称和用户头像
- 创建LV报错/dev/vgdata/data: not found: device not cleared Aborting. Failed to wipe start of new LV.
- Flash选择合适的稳压芯片
- 数据整理(Data Wrangling)
- MIMO-OFDM学习笔记(传播与衰落)