文章目录
属性 Field
定义
属性是类的静态特征，也叫成员变量。
语法格式
修饰符 数据类型 属性名 = 初始化值 ;
- 常用权限修饰符：private、缺省、protected、public；其他修饰符：static、final
- 数据类型：任何基本数据类型(如int、boolean) 或 任何引用数据类型。
- 属性名：属于标识符，符合命名规则和规范即可。
public class Person{
//声明private变量 age
private int age;
//声明public变量 name
public String name = “Lila”;
}
分类
成员变量：在方法体外，类体内声明的变量。
局部变量：在方法体内部声明的变量。
赋值顺序
赋值的先后顺序：① - ② - ③ - ④
① 默认初始化
② 显式初始化、多个初始化块依次被执行（同级别下按先后顺序执行）
③ 构造器中初始化
④ 通过“对象.属性“或“对象.方法”的方式赋值
方法 Method
定义
方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。
-
将功能封装为方法的目的是，可以实现代码重用，简化代码。
-
Java里的方法不能独立存在，所有的方法必须定义在类里。
语法格式
修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛
方法体程序代码;
return 返回值;
｝
其中：修饰符：public，缺省，private，protected，static，abstract，final等
方法的调用
方法通过方法名被调用，且只有被调用才会执行。
注意
- 方法被调用一次，就会执行一次。
- 没有具体返回值的情况，返回值类型用关键字void表示，那么方法体中可以不必使用return语句。如果使用，仅用来结束方法。
- 定义方法时，方法的结果应该返回给调用者，交由调用者处理。
- 方法中只能调用方法或当前类的属性，不可以在方法内部定义方法。
方法详解
构造器
作用
- 创建对象；给对象进行初始化
语法格式
- 修饰符 类名 (参数列表) {
初始化语句；
}
特点
- 具有与类相同的名称
- 不声明返回值类型（与声明为void不同）
- 不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值
//创建Animal类的实例：Animal a = new Animal();
//调用构造器，将legs初始化为4。
public class Animal{
private int legs;
//构造器
public Animal(){
legs = 4;
}
public setLegs(int i){
legs = i;
}
public int getLegs(){
return legs;
}
}
分类
- 隐式无参构造器（系统默认提供）
- 显式定义一个或多个构造器（无参、有参）
注意
- Java语言中，每个类都至少有一个构造器
- 默认构造器的修饰符与所属类的修饰符一致
- 一旦显式定义了构造器，则系统不再提供默认构造器
- 一个类可以创建多个重载的构造器
- 父类的构造器不可被子类继承
代码块
作用
对Java类或对象进行初始化。
分类
静态代码块：static修饰的代码块
内部可以有输出语句。
可以对类的属性、类的声明进行初始化操作，通常用于初始化static的属性。
随着类的加载而执行，而且只执行一次，静态代码块的执行要优先于非静态代码块的执行。
如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构
非静态代码块：没有static修饰的代码块
内部可以有输出语句。
可以对类的属性、类的声明进行初始化操作。
每创建一个对象，就执行一次非静态代码块，且先于构造器执行。
如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行。
非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法。
注意
先父后子，静态先行。
class Root{
static{
System.out.println("Root的静态初始化块");
}
{
System.out.println("Root的普通初始化块");
}
public Root(){
super();
System.out.println("Root的无参数的构造器");
}
}
class Mid extends Root{
static{
System.out.println("Mid的静态初始化块");
}
{
System.out.println("Mid的普通初始化块");
}
public Mid(){
super();
System.out.println("Mid的无参数的构造器");
}
public Mid(String msg){
//通过this调用同一类中重载的构造器
this();
System.out.println("Mid的带参数构造器，其参数值："
+ msg);
}
}
class Leaf extends Mid{
static{
System.out.println("Leaf的静态初始化块");
}
{
System.out.println("Leaf的普通初始化块");
}
public Leaf(){
//通过super调用父类中有一个字符串参数的构造器
super("尚硅谷");
System.out.println("Leaf的构造器");
}
}
public class LeafTest{
public static void main(String[] args){
new Leaf();
System.out.println();
new Leaf();
}
}
输出结果：
Root的静态初始化块
Mid的静态初始化块
Leaf的静态初始化块
Root的普通初始化块
Root的无参数的构造器
Mid的普通初始化块
Mid的无参数的构造器
Mid的带参数构造器，其参数值：尚硅谷
Leaf的普通初始化块
Leaf的构造器
Root的普通初始化块
Root的无参数的构造器
Mid的普通初始化块
Mid的无参数的构造器
Mid的带参数构造器，其参数值：尚硅谷
Leaf的普通初始化块
Leaf的构造器
内部类
定义
在 Java 中允许在一个类（或方法、语句块）的内部定义另一个类，称为内部类。
分类
成员内部类
（1）类级，有 static 修饰
（2）对象级：成员式，无 static 修饰
局部内部类(方法内、代码块内、构造器内)
（1）有名字：本地内部类
（2）没名字：匿名内部类
成员内部类
一方面，作为外部类的成员：
-
可以调用外部类的结构。
-
可以被static修饰，若有 static修饰就为类级，否则为对象级。类级可以通过外部类直接访问；对象级需要先生成外部的对象后才能访问。
-
可以被4种不同的权限修饰符修饰。
另一方面，作为一个类：
-
在成员内部类里面可以定义属性、方法、构造器等，不能跟外部类同名。
-
可以被final修饰，表示此类不能被继承。
-
可以被abstract修饰。
-
编译以后生成OuterClass$InnerClass.class字节码文件（也适用于局部内部类）。
注意
-
非static的成员内部类中的成员不能声明为static的，只有外部类或static的成员内部类中才可以。
-
外部类访问成员内部类的成员，需要“内部类.成员”或“内部类对象.成员”的方式。
-
成员内部类可以直接使用外部类的所有成员，包括私有的数据。
-
当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的。
实例化方法
//方法一：
Outer.Inner in=new Outer().new Inner();
//方法二：
Outer o=new Outer();
Outer.Inner I=o.new Inner();
//如果内部类是static（类级）的，只能用下面方法：
Outer.Inner in=new Outer.Inner();
局部内部类
- 只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类。
- 局部内部类可以使用外部类的成员，包括私有的。
- 局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局部变量的声明周期不同所致。
- 局部内部类和局部变量地位类似，不能使用public,protected,缺省,private。
- 局部内部类不可以是 static 的，里边也不能定义 static 成员。
- 它的对象可以通过外部方法的返回值返回使用，返回值类型只能是局部内部类的父类或父接口类型。
匿名内部类
- 匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
- 匿名内部类必须继承父类或实现接口.
- 匿名内部类只能有一个对象.
- 匿名内部类对象只能使用多态形式引用 .
/**
* 内部类（inner class）
* 成员内部类--类级内部类
*/
public class Outer1 {
public static void main(String[] args) {
//静态成员内部类的对象的创建--创建的方式和对象级的创建方式不同
Outer_2.Inner inner = new Outer_2.Inner();
inner.doStuff();
}
}
class Outer_2 {
private static int size;
int a;
static class Inner {
public void doStuff() {
// a++;//类级的不可以调用外部类的类级成员变量
size++;
System.out.println("size=" + size);
}
}
}
/**
* 内部类（inner class）
* 成员内部类--对象级内部类
*/
public class Outer2 {
private int size;
static int a;
public class Inner {
private int counter = 10;
public void doStuff() {
a++;//对象级内部类可以调用外部类的类级成员变量
size++;//内部类可以调用外部类的私有属性
}
}
public void test() {
// 编译错误,外部类不能访问内部类的private变量
// System.out.println(counter);
}
public static void main(String[] args) {
Outer2 outer = new Outer2();
//在本类中实例化内部类
//第一种
Inner inner = outer.new Inner();
//第二种
Outer2.Inner in = new Outer2().new Inner();
inner.doStuff();
in.doStuff();
System.out.println(outer.size);
System.out.println(inner.counter);
}
}
/**
* 内部类（inner class）
* 局部式内部类--有名字: 本地内部类
*/
public final class Outer3 {
public static final int TOTAL_NUMBER = 5;
public int id = 123;
public void test1() {
final int a = 15;
String s = "t1";
class Inner {
public void innerTest() {
System.out.println(TOTAL_NUMBER);
System.out.println(id);
System.out.println(a);
System.out.println(s);//JDK8以上合法
}
}
new Inner().innerTest();
}
public static void main(String[] args) {
Outer3 t = new Outer3();
t.test1();
}
}
/**
* 内部类（inner class）
* 局部式内部类--没名字：匿名内部类
*/
public class Outer4 {
public void add() {
int a = 10, b = 20;
// 此时体现了匿名内部类
new Test_2() {
@Override
void print(int a, int b) {
System.out.println(a + b);
}
}.print(a, b);
}
public static void main(String[] args) {
Outer4 t = new Outer4();
t.add();
}
}
abstract class Test_2 {
abstract void print(int a, int b);}
// 相当于13~19行
// class Test_3 extends Test_2 {
// void print(int a, int b) {
// System.out.println(a + b);
// }
// }
修饰符适用范围
753
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
