少年的肩膀,就应该是这样才对嘛,什么国仇家恨,浩然正气,都不要急,先挑起清风明月、杨柳依依和草长莺飞,少年郎的肩头,本就应当满是美好的事物啊。
1.类变量和类方法
1.1 类变量
介绍
类变量也叫静态变量,是该类的所有对象共享的变量,任何一个该类的对象去访问它时,取到的都是相同的值,同样任何一个该类的对象去修改它时,修改的也是同一个变量。
定义
访问修饰符 static 数据类型 变量名;
访问类变量
类名.类变量名;(推荐)
对象名.类变量名;
代码示例
class Child {
private String name;
// 定义一个类变量(静态变量)
public static int count = 0;
public Child(String name) {
this.name = name;
}
public void join() {
System.out.println(name + " 加入了游戏..");
}
}
public static void main(String[] args) {
//定义一个变量 count, 统计有多少小孩加入了游戏
int count = 0;
Child child1 = new Child("路明非");
child1.join();
child1.count++;
Child child2 = new Child("诺诺");
child2.join();
child2.count++;
Child child3 = new Child("大师兄");
child3.join();
child3.count++;
// 类变量,可以通过类名来访问
System.out.println("共有" + Child.count + " 小孩加入了游戏...");
System.out.println("child1.count=" + child1.count); //3
System.out.println("child2.count=" + child2.count); //3
System.out.println("child3.count=" + child3.count); //3
}
注意
- 什么时候需要用类变量
当需要让某个类的所有对象都共享一个变量时,就可以考虑使用类变量。
- 类变量与实例变量区别
类变量是该类所有对象共享的,实例变量是每个对象独享的。
- 类变量的生命周期
类变量的生命周期是随类的加载开始,随着类的消亡而销毁。
1.2 类方法
介绍
类方法也叫静态方法。
定义
访问修饰符 static 数据返回类型 方法名(){ }
类方法的调用
类名.类方法名
对象名.类方法名
代码示例
class MyTools {
// 求出两个数的和
public static double calSum(double n1, double n2) {
return n1 + n2;
}
//可以写出很多这样的工具方法...
}
public static void main(String[] args) {
System.out.println(MyTools.calSum(10, 10));
}
注意
- 什么时候使用
当方法中不涉及到任何和对象相关的成员,则可以将方法设计为静态方法,提高开发效率。
- 类方法和普通方法都是随着类的加载而加载,将结构信息存储在方法区
类方法中无this参数,普通方法中隐含this参数。
- 类方法的访问
类方法(静态方法)中只能访问静态变量或静态方法。
普通成员方法,既可以访问非静态成员,也可以访问静态成员。
2.理解 main 方法
语法
public static void main(String[] args){ }
注意
在 main()方法中,我们可以直接调用 main 方法所在类的静态方法或静态属性。
访问该类中的非静态成员,必须创建该类的一个实例对象后,才能通过这个对象去访问类中的非静态成员。
代码示例
public class Main01 {
// 静态变量
private static String name = "路明非";
// 非静态的变量/属性
private int n1 = 10;
// 静态方法
public static void hi() {
System.out.println("Main01 的 hi 方法");
}
// 非静态方法
public void cry() {
System.out.println("Main01 的 cry 方法");
}
public static void main(String[] args) {
// 1. 静态方法 main 可以访问本类的静态成员和静态方法
System.out.println("name=" + name);
hi();
// 2. 静态方法 main 不可以访问本类的非静态成员和普通方法
//System.out.println("n1=" + n1);//错误
//cry();
// 3. 静态方法 main 要访问本类的非静态成员,需要先创建对象 , 再调用
Main01 main01 = new Main01();
System.out.println(main01.n1);
main01.cry();
}
}
3.代码块
介绍
代码块又称初始化块,属于类中的成员(是类的一部分),类似于方法,将逻辑语句封装在方法体中,通过{}包起来。
但是和方法不同,没有方法名,没有返回,没有参数,只有方法体,而且不用通过对象或类显式调用,而是在加载类时,或创建对象时隐式调用。
语法:
[修饰符] {
代码块;
};
- 说明
1. 修饰符可选,要写的话只能写static
2. 代码块分为两类,使用 static 修饰的叫静态代码块,没有 static 修饰的,叫普通代码块
3. 最后的 ; 可以写也可以省略
好处
相当于另外一种形式的构造器(对构造器的补充机制),可以做初始化操作。
如果多个构造器中有重复的语句,可以抽取到初始化块中,提高代码的重用。
代码示例:
public class CodeBlock01 {
public static void main(String[] args) {
Movie movie = new Movie("你好,李焕英");
System.out.println("===============");
Movie movie2 = new Movie("唐探 3", 100, "陈思诚");
}
}
class Movie {
private String name;
private double price;
private String director;
{
System.out.println("电影屏幕打开...");
System.out.println("广告开始...");
System.out.println("电影正是开始...");
};
public Movie(String name) {
System.out.println("Movie(String name) 被调用...");
this.name = name;
}
public Movie(String name, double price) {
this.name = name;
this.price = price;
}
public Movie(String name, double price, String director) {
System.out.println("Movie(String name, double price, String director) 被调用...");
this.name = name;
this.price = price;
this.director = director;
}
}
4.final 关键字
在某些情况下,有如下需求,就会使用到final
- 当不希望类被继承时
- 当不希望父类的某个方法被子类覆盖/重写时
- 当不希望某个属性值被修改时
final 使用注意
- final修饰的属性又叫常量,一般用大写字母加下划线(XX_XX_XX)来命名
- final修饰的属性在定义时,必须赋初值,并且以后不能再修改
- final不能修饰构造方法
- final和static往往搭配使用,效率更高,不会导致类加载,底层编译器做了优化处理
- 包装类(Integer,Double,Float等都是final),String也是final类(固定长度)
代码示例
public class FinalExercise01 {
public static void main(String[] args) {
Circle circle = new Circle(5.0);
System.out.println("面积=" + circle.calArea());
}
}
class Circle {
private double radius;
private final double PI = 3.14; // 常量3.14
public Circle(double radius) {
this.radius = radius;
}
public double calArea() {
return PI * radius * radius;
}
}
5.抽象类
介绍
当父类的一些方法不能确定时,可以用 abstract 关键字来修饰该方法,这个方法就是抽象方法,用abstract 来修饰该类就是抽象类。(将方法要实现的功能放到子类去实现)
注意
抽象类不能被实例化
抽象类不一定要包含 abstract 方法。也就是说,抽象类可以没有abstract方法。
一旦类包含了abstract方法,则这个类必须声明为abstract
abstract只能修饰类和方法,不能修饰属性和其它的。
abstract class Animal {
private String name;
public Animal(String name) {
this.name = name;
}
// public void eat() {
// System.out.println("这是一个动物,但是不知道吃什么..");
// }
public abstract void eat();
}
6.接口
usb插槽就是现实中的接口。(统一规范)
你可以把手机、相机、U盘等都插在usb插槽上,而不用担心那个插槽是专门插哪个的,原因是做USB插槽的厂家和做各种设备的厂家都遵守了统一的规定包括尺寸、排线等。
代码示例
// 定义USB接口
public interface UsbInterface {
public void start();
public void stop();
}
// 实现接口,把接口方法实现
public class Camera implements UsbInterface{
@Override
public void start() {
System.out.println("相机开始工作...");
}
@Override
public void stop() {
System.out.println("相机停止工作....");
}
}
public class Phone implements UsbInterface {
@Override
public void start() {
System.out.println("手机开始工作...");
}
@Override
public void stop() {
System.out.println("手机停止工作.....");
}
}
语法
interface 接口名 {
// 属性
// 抽象方法
}
class 类名 implements 接口 {
// 自己属性;
// 自己方法;
// 必须实现接口的抽象方法
}
注意
- 接口不能被实例化
- 接口中所有的方法是public方法,接口中抽象方法,可以不用abstract修饰
- 一个普通类实现接口,就必须将该接口的所有方法都实现
- 抽象类实现接口,可以不用实现接口方法
- 一个类可以实现多个接口
- 接口中的属性,只能是final的,而且是public static final修饰符
- 接口中属性的访问形式:接口名.属性名
- 接口不能继承其它的类,但是可以继承多个别的接口
- 接口的修饰符只能是public和默认,这点和类的修饰符是一样的
实现接口 vs 继承类
- 解决的问题不同
继承的价值主要在于:解决代码的复用性和可维护性
接口的价值主要在于:设计统一规范
- 接口比继承更加灵活
继承时满足 is -a 的关系,接口只需满足 like -a 的关系
接口在一定程度上实现代码解耦(接口规范性 + 动态绑定机制)
7.内部类
介绍
一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class),嵌套其它类的类称为外部类(outer class)。这是类的第五大成员(属性、方法、构造器、代码块、内部类),内部类最大的特点就是可以直接访问私有属性,并且可以体现类与类之间的包含关系。
语法
class OutClass {
class InnerClass {
}
}
7.1 内部类的分类
定义在外部类局部位置上(一般是方法中):
- 局部内部类(有类名)
- 匿名内部类(没有类名)
定义在外部类的成员位置上:
- 成员内部类(没有static修饰)
- 静态内部类(使用static修饰)
7.2 局部内部类
局部内部类的使用
- 可以直接访问外部类的所有成员,包括私有的
- 作用域:仅仅在定义它的方法或代码块中
- 如果外部类和局部内部类的成员重名时,默认遵循就近原则,如果想访问外部类的成员,可以使用(外部类.this.成员)去访问
局部内部类代码示例
public class LocalInnerClass {
public static void main(String[] args) {
Outer02 outer02 = new Outer02();
outer02.m1();
System.out.println("outer02 的 hashcode=" + outer02);
}
}
class Outer02 {
private int n1 = 100;
private void m2() {
System.out.println("Outer02 m2()");
}
public void m1() {
// 定义局部内部类
final class Inner02 {
private int n1 = 800;
// 调用外部类的私有属性和方法
public void f1() {
System.out.println("n1=" + n1 + " 外部类的 n1=" + Outer02.this.n1);
System.out.println("Outer02.this hashcode=" + Outer02.this);
}
m2();
}
}
// 外部类实例化内部类对象,调用内部类的属性和方法
Inner02 inner02 = new Inner02();
inner02.f1();
}
匿名内部类代码示例(当只要使用一次时,很方便)
public class InnerClassExercise01 {
public static void main(String[] args) {
//传统方法
f1(new Picture());
// 当做实参直接传递,简洁高效
f1(new IL() {
@Override
public void show() {
System.out.println("这是一副名画~~...");
}
});
}
// 静态方法,形参是接口类型
public static void f1(IL il) {
il.show();
}
// 接口
interface IL {
void show();
}
// 硬编码实现
class Picture implements IL {
@Override
public void show() {
System.out.println("这是一副名画 XX...");
}
}
7.3 成员内部类
定义在外部类的成员位置,并且没有 static 修饰。
- 可以直接访问外部类的所有成员,包括私有的
- 作用域:和外部类的其它成员一样,为整个类体
- 如果外部类和局部内部类的成员重名时,默认遵循就近原则,如果想访问外部类的成员,可以使用(外部类.this.成员)去访问
成员内部类代码示例
public class MemberInnerClass01 {
public static void main(String[] args) {
Outer08 outer08 = new Outer08();
outer08.t1();
Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
inner08Instance.say();
}
}
class Outer08 {
private int n1 = 10;
public String name = "张三";
private void hi() {
System.out.println("hi()方法...");
}
// 定义成员内部类
class Inner08 {
private double sal = 99.8;
private int n1 = 66;
public void say() {
System.out.println("n1 = " + n1 + " name = " + name + " 外部类的 n1=" + Outer08.this.n1);
hi();
}
}
//写方法
public void t1() {
Inner08 inner08 = new Inner08();
inner08.say();
System.out.println(inner08.sal);
}
}
静态内部类
定义在外部类的成员位置,并且有 static 修饰。
- 可以直接访问外部类的所有成员,包括私有的
- 作用域:和外部类的其它成员一样,为整个类体
- 如果外部类和静态内部类的成员重名时,默认遵循就近原则,如果想访问外部类的成员,可以使用(外部类.this.成员)去访问