目录
三大修饰符
代码块
作用·：封装一段代码
语法：
{ }
定义位置：
1.方法中：此时不会影响代码的运行，和没定义没有区别
2.类中，方法以外：
此时每次创建该对象时，就会执行此处代码
该代码块在构造函数前执行
在对象的属性赋初始值之后
package doume1;
public class test1 {
public int str;
public test1(){//类中的无参构造
System.out.println("这是无参构造");
}
{//声明一个代码块
System.out.println(str);
System.out.println("这是代码块");
}
}
package doume1;
public class test2 extends test1 {
public static void main(String[] args) {
test1 aTest1=new test1();
test1 aTest2=new test1();//创建两个对象
}
}
由运行结果可验证结论 。在对象赋值之后，构造函数之前，
static修饰符
含义：静态
可以修饰：
1.属性，当static修饰属性后，此属性变为共有，如果一个对其更改，则此类的对象所有此属性都会更改
使用方法：
对象名.属性名 或 类名.属性名
static修饰的属性不管改类有多少对象，此属性只有一个
package doume1;
public class test1 {
private String name;
private String sex;
private int age;
public static String classNumber;//使用static修饰此属性
public test1(){
super();
}
public test1(String name, String sex, int age) {
super();
this.name = name;
this.sex = sex;
this.age = age;
}
public void showInfo() {//打印的一个方法
System.out.println("姓名:"+name+",性别:"+sex+",年龄:"+age+",班级号:"+classNumber);
}
}package doume1;
public class test2 {
public static void main(String[] args) {
test1 s01 = new test1("老王", "男", 17);
test1 s02 = new test1("小朝阳", "男", 18);
s01.showInfo();
s02.showInfo();
System.out.println("-------------------");
s01.classNumber = "计本1701";//使用方法：对象名.属性名
s01.showInfo();
s02.showInfo();
System.out.println("-------------------");
//static修饰的属性可以使用类名直接调用,也可以使用对象名调用
test1.classNumber = "毕业了";使用方法：类名属性名
s01.showInfo();
s02.showInfo();
}
}
可以看到
修饰classNumber这个属性后，这个属性唯一 了。
2.方法
含义：静态方法
使用方法：
对象名.属性名(实参列表);
或
类名.属性名(实参列表)；
A.test02();//使用类名调用静态方法
A a = new A();
//使用对象可以调用静态方法
a.testStatic();注意1.静态方法中不能使用非静态方法(没有staitic修饰的属性和方法)
2.静态方法中不能使用this或super关键字
3.使得static修饰的方法成为类的方法，使用时通过“类名.方法名”的方式就可以方便的使用了，这样就不用new关键字创建对象再使用，从而节省了资源。
可以看到如果在静态方法中直接使用非静态方法和非静态属性会报错
3.代码块
调用时机：jvm加载类时调用
由于一个类只会被加载一次，所以此代码块只会被执行一次
语法:
static{
}
使用static静态代码块进行初始化与直接在定义变量的时候初始化效果是一样的，但是它们的先后顺序可能会对变量的值造成影响。
它们是按照在代码中书写的顺序依次进行初始化的，所以后面的赋值操作会覆盖前面的值
内部类（之后才学）
类加载
使用该类时会加载
如：使用类名调用静态属性或方法
创建该类对象
创建其子类对象
获取类对象
在静态下对象的创建过程
1.加载该类
2.给静态属性赋初始值
3.执行静态代码块中的代码
4.在堆内存中开辟空间
5.给非静态属性赋初始值
6.执行代码块中的代码
7.执行构造函数
8.赋值给栈的引用
final修饰符
含义：最终的，不可修改的
可以修饰：
1. 类
语法：
访问权限修饰符 final class 类名{
}
特点：final修饰的类不能被别的类继承
2.属性
语法：
访问权限修饰符 final 数据类型 变量名=值
特点：final修饰的属性必须在声名时赋值，此值不可被修改
3.方法
语法：
访问权限修饰符 final 返回值类型 方法名(形参列表) {
}
特点：
final修饰的方法不能被重写
4.局部变量
语法：
final 数据类型 变量名；
注意：final修饰的局部变量只能赋值一次
名称：
公共静态常量：使用public static final修饰的属性
公共静态方法：使用public static修饰的方法
常量：不能被修改的变量或值
abstract修饰符
含义：抽象的
可以修饰
1.类
特点：不能直接创建对象
语法：
访问权限修饰符 abstract class 类名{
属性
方法
构造函数
代码块
静态代码块
}
2.方法：
特点：没有方法体
语法：访问权限修饰符 abstract 返回值类型 方法名(形参列表)；
注意：有抽象方法的一定是抽象类，
抽象类中不一定有抽象方法
类继承于抽象类要么重写父类所有抽象方法，要么自己也是抽象类
abstract具体说明：
1.abstract修饰的抽象类不能被实例化，无法使用new关键字调用抽象类的构造函数来创建实例，其构造函数主要是用于其子类调用。
2.abstract修饰类表明此类只能被继承，abstract修饰方法时，表明此方法必须由子方法重写
@Override，如果想重写父类，可在重写方法前加@Override，系统会帮忙检查重写方法的可行性
3.abstract不能修饰成员变量，不能修饰局部变量。
4.抽象类是多抽象出来的父类，像是子类的一个模板，避免子类随意设计
abstract不能与static一起使用，
abstract不能与final一起使用
final可以与static一起使用，一起修饰属性，方法
例子练一练：
宠物医生给宠物治病,宠物有猫,狗,鱼
宠物医生:周医生
宠物:
旺财,公(狗)
布丁,雌(猫)
金龙,雌(鱼)
周医生给以上宠物治病,病好后,狗汪汪,猫喵喵,鱼跳跳
分析：
对象有猫,狗,鱼，周医生
可有动物类和医生类
这几个动物动作那是有点抽象的，所以动物类可以是个抽象类，方法里也有个抽象方法
首先创建动物类
package alomao;
public abstract class Alim {//创建动物类
private String nameString;
private String sexString;//给变量加权限
public Alim() {//无参构造
}
public Alim(String nameString, String sexString) {//有参构造
this.nameString = nameString;
this.sexString = sexString;
}
public String getNameString() {//get，set方法
return nameString;
}
public void setNameString(String nameString) {
this.nameString = nameString;
}
public String getSexString() {
return sexString;
}
public void setSexString(String sexString) {
this.sexString = sexString;
}
public abstract void jiAo();//抽象一个jiAo类
}
具体某个动物类
package alomao;
public class Dog extends Alim {
public Dog() {//创建有参构造无参构造
super();//调用父类构造函数
}
public Dog(String nameString, String sexString) {
super(nameString, sexString);//调用父类构造函数
}
@Override//准备重写父类，系统检查一下
public void jiAo() {
System.out.println(getNameString()+"旺旺");
}
}
医生类
package alomao;
public class Docter {
private String nameString;
public Docter() {
super();
}
public Docter(String nameString) {
super();
this.nameString = nameString;
}
public String getNameString() {
return nameString;
}
public void setNameString(String nameString) {
this.nameString = nameString;
}
public void kanBing(Alim alim) {
System.out.println(nameString+"给"+alim.getNameString()+"看病");
alim.jiAo();//调用
}
}调用运行
public class Test {
public static void main(String[] args) {
Dog wangDog=new Dog("富贵","公");
Cat buCat=new Cat("布丁","雌");
Fish jinFish=new Fish("金鱼","雌");
Docter zhouDocter=new Docter("周医生");
zhouDocter.kanBing(wangDog);
zhouDocter.kanBing(buCat);
zhouDocter.kanBing(jinFish);
}
}
运行成功
例2：记录一个类的对象创建次数
可以使用代码块中统计；
成功
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
