少年的肩膀，就应该是这样才对嘛，什么国仇家恨，浩然正气，都不要急，先挑起清风明月、杨柳依依和草长莺飞，少年郎的肩头，本就应当满是美好的事物啊。
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.成员）去访问
1110
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
