一.类与对象
1.类
1.1创建类
class 类名
1.2成员变量
1.什么是成员变量
定义在类中方法外的变量叫成员变量
2.定义格式
数据类型 变量名;
这里的变量可以不用给值,也可以给值,如果不给值
int类型 默认为 0
double 默认为0.0
字符串 默认为 null
例如
int a;
1.3成员方法
1.什么是成员方法
在类中定义的方法
2.定义格式
权限修饰符 返回值类型 方法名(参数类型 参数名){
方法体
return 返回值
}
3.注意事项
a、如果成员方法没有返回值,则返回值类型可以用void代替
b、返回值类型要与方法返回值类型一致
2.对象
1.创建对象
1创建格式
类名 对象名=new 对象名;
2.访问对象属性与行为
1.访问对象属性
对象名.成员变量名;
2.访问对象行为
对象名.成员方法().
3.类与对象的几种实例(简单型)
3.1一个类一个对象
1.创建一个学生类,学生拥有学号,姓名,年龄,学生可以学习,吃饭,睡觉
2.创建一个学生对象
package com.shujia.day05;
/*
学生: class Student:
属性:学号,姓名,年龄 成员变量:id,name,age
行为:学习,吃饭,睡觉 成员方法:study(),eat().sleep()
手机: class Phone:
属性:品牌 颜色 价格 成员变量:brand color price
行为:打电话 给xxx发短信 打游戏 成员方法:call() sendMessage(String n) playGame()
*/
public class Student {
// 属性:
// 成员变量:在类中方法外定义的变量,叫做成员变量
// 数据类型 变量名; 对于成员变量而言,在定义的时候,可以手动赋值,也可以不给值,系统会赋予默认值。
int id;
String name;
int age;
//行为:成员方法
//从此刻开始将之前的static去掉使用,只保留public
public String study(){
System.out.println("学习");
return "java";
}
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
}
class StudentDemo1{
public static void main(String[] args) {
//根据编写好的类,创建第一个学生对象
//语句定义格式:类名 对象名 = new 类名();
Student s1 = new Student();
//如何获取对象中的属性(成员变量)
//语句定义格式:对象名.成员变量名;
//获取学号
int id = s1.id;
System.out.println(id); // 0
System.out.println(s1.name); // null
System.out.println(s1.age); // 0
s1.id = 1001;
s1.name = "丁义杰";
s1.age = 18;
System.out.println(s1.id);
System.out.println(s1.name);
System.out.println(s1.age);
//如何调用对象中的方法呢?
//语句定义格式:
//对象名.方法名();
s1.eat();
s1.eat();
s1.eat();
String res1 = s1.study(); // "java"
System.out.println(res1);
}
}
3.2两个引用指向同一个对象
package com.shujia.day05;
/*
2个对象的内存图 其中有两个引用指向同一个对象
*/
class Phone {
String brand;
String color;
int price;
public void call() {
System.out.println("打电话!");
}
public void sendMessage(String s) {
System.out.println("发短信给 " + s);
}
public void playGame(){
System.out.println("打游戏");
}
}
public class PhoneDemo {
public static void main(String[] args) {
//创建第一个手机对象
Phone p1 = new Phone();
p1.brand = "华为mate60 pro";
p1.color = "黑色";
p1.price = 7999;
System.out.println("品牌:"+ p1.brand);
System.out.println("颜色:"+ p1.color);
System.out.println("价格:"+ p1.price);
p1.call();
p1.sendMessage("马云");
p1.playGame();
// 创建另一个引用,指向同一个对象
Phone p2 = p1;
p2.price = 5999;
System.out.println("-------------------");
System.out.println("品牌:"+ p1.brand);
System.out.println("颜色:"+ p1.color);
System.out.println("价格:"+ p1.price);
System.out.println("-------------------");
System.out.println("品牌:"+ p2.brand);
System.out.println("颜色:"+ p2.color);
System.out.println("价格:"+ p2.price);
}
}
3.3匿名对象
1.什么叫匿名对象
是一种对象的简化方式
例如 p2=new Phone()
2.使用情况
a、对象调用方法仅仅使用一次
b、作为实际参数传递
3.4对象是引用数据类型
1.对象可以作为参数传递
形式 该类 该类new出来的对象名
2.当参数的类型是类的时候,调用他需要传入该类的对象
package com.shujia.day5;
class Teacher{
public void fun1(int a,int b){
System.out.println(a+b);
}
public void teach(){
System.out.println("教学");
}
}
public class TeacherDemo2 {
public void show(Teacher t){ //类作为参数类型时,传入的是引入该类的对象
t.teach(); //因为上面的数据类型是类,所以可以使用该类的成员方法
}
}
class TeacherText1{
public static void main(String[] args) {
//创建Teacher对象
Teacher teacher = new Teacher();
teacher.fun1(4,5);
//创建TeacherDemo2对象
TeacherDemo2 teacherDemo2 = new TeacherDemo2();
teacherDemo2.show(teacher);
}
}
二.封装
1.相关概念知识
1.1概念
1.指隐藏对象的属性和实现细节,仅对外提供公共访问方式。
1.2好处
1.隐藏实现细节,提供公共的访问方式
2.提高了代码的复用性
3.提高安全性
1.3封装原则
1.将不需要对外提供的内容都隐藏起来。
2.把属性隐藏,提供公共方法对其访问。
2.private关键字
2.1.相关知识
1.是一个权限修饰符。
2.可以修饰成员(成员变量和成员方法)
3.被private修饰的成员只在本类中才能访问。
2.2.private修饰成员变量的形式
1.private修饰的成员变量可以在本类中之间使用
package com.shujia.day6;
class Student1{
private int a;
public void get(int a){
System.out.println(a);
}
}
public class PrivateDemo2 {
public static void main(String[] args) {
Student1 student1 = new Student1();
student1.get(3);
}
}
2.private修饰的成员变量在其他类或者对象中使用
1.使用setXxx()方法进行赋值,这个是有参无返回值函数
2.使用getXxx()方法来进行获取,这个是无参有返回值函数
3.创建一个对象后用etXxx()方法进行赋值,输出用getXxx()方法
package com.shujia.day6;
class Teacher{
private int age;
private String name;
//setAge()是有参无返回值的函数
public void setAge(int a){
age=a;
}
//getAge()是无参有返回值的函数
public int getAge(){
return age;
}
public void setName(String b){
name=b;
}
public String getName(){
return name;
}
}
public class PrivateDemo3 {
public static void main(String[] args) {
Teacher teacher = new Teacher();
//赋值是通过setAge
teacher.setName("zhansgan");
teacher.setAge(18);
//获取数据是getAge()
System.out.println(teacher.getAge());
System.out.println(teacher.getName());
}
}
同时这也是定义一个标准类的1.0版本
2.3private修饰成员方法
1.不能被对象直接使用
package com.shujia.day6;
class Teacher{
private int age;
private String name;
//setAge()是有参无返回值的函数
public void setAge(int a){
age=a;
}
//getAge()是无参有返回值的函数
public int getAge(){
return age;
}
public void setName(String b){
name=b;
}
public String getName(){
return name;
}
private void show(){
System.out.println("jiaoxue");
}
}
public class PrivateDemo3 {
public static void main(String[] args) {
Teacher teacher = new Teacher();
//赋值是通过setAge
teacher.setName("zhansgan");
teacher.setAge(18);
//获取数据是getAge()
System.out.println(teacher.getAge());
System.out.println(teacher.getName());
teacher.show();
}
}
这个Teacher类中的show方法被private修饰,而创建teacher对象中直接使用show方法是错误的,这个程序是报错的,接下来这样修改即可在对象中调用被private修饰的成员方法
package com.shujia.day6;
class Teacher{
private int age;
private String name;
//setAge()是有参无返回值的函数
public void setAge(int a){
age=a;
}
//getAge()是无参有返回值的函数
public int getAge(){
return age;
}
public void setName(String b){
name=b;
}
public String getName(){
return name;
}
private void show(){
System.out.println("jiaoxue");
}
public void getShow(){
show();
}
}
public class PrivateDemo3 {
public static void main(String[] args) {
Teacher teacher = new Teacher();
//赋值是通过setAge
teacher.setName("zhansgan");
teacher.setAge(18);
//获取数据是getAge()
System.out.println(teacher.getAge());
System.out.println(teacher.getName());
teacher.getShow();
}
}
直接重新定义一个被public修饰的方法来接收show方法,那样再创建的对象中可以使用被public修饰的方法
3.this关键字
3.1相关知识
1.方法被哪个对象调用,this就代表那个对象
2.什么时候使用
a.局部变量隐藏成员变量
b.其他用法后面和super一起讲解
3.可以修饰成员变量也可以修饰成员方法
3.2使用
package com.shujia.day6;
class Teacher1{
String name;
int age;
public void setName(String name){
this.name=name;
}
public String getName(){
return this.name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return this.age;
}
}
public class ThisDemo1 {
public static void main(String[] args) {
Teacher1 teacher1 = new Teacher1();
teacher1.setAge(19);
teacher1.setName("xiaoming");
System.out.println(teacher1.getAge());
System.out.println(teacher1.getName());
}
}
4.构造方法
4.1相关知识
1.构造方法作用概述
给对象的数据进行初始化
2.构造方法格式、
1.方法名与类名相同 类名(){方法体}
2.没有返回值类型,
3.连void都没有 没有具体的返回值
3.构造方法注意事项
1.如果你不提供构造方法,系统会给出默认构造方法
2.如果你提供了构造方法,系统将不再提供
3.构造方法也是可以重载的
4.2使用方法
1.创建对象时使用,立即使用
若有构造代码块,则后面new出来对象即可直接运行代码块的内容(内容看代码块)
package com.shujia.day6;
class Phone{
private int price;
private String brand;
Phone(){
System.out.println("这是无参的构造方法");
}
Phone(String s){
System.out.println("这是有参的构造方法"+s);
}
}
public class StructureDemo1 {
public static void main(String[] args) {
Phone phone = new Phone("aaa");
}
}
创建对象时看你选择哪个构造方法 是无参还是有参
2.在有构造方法时不需要setXxx方法一样可以进行赋值
package com.shujia.day6;
class Teacher1{
String name;
int age;
Teacher1(String name,int age){
this.age=age;
this.name=name;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return this.name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return this.age;
}
}
public class ThisDemo1 {
public static void main(String[] args) {
Teacher1 teacher1 = new Teacher1("xiaom",18);
// teacher1.setAge(19);
// teacher1.setName("xiaoming");
System.out.println(teacher1.getAge());
System.out.println(teacher1.getName());
}
}
3.java标准类的定义2.0版本
1、成员变量需要使用private关键字修饰
2、提供两个构造方法(无参构造方法/有参构造方法)
3、对每一个私有的成员变量提供公共的setXxx()和getXxx()
4、提供一个show方法,展示对象的成员变量值的情况(这个方法后面会被另外一个方法替换)
这个是通过setXxx赋值的
package com.shujia.day6;
class Phone1{
private int price;
private String brand;
Phone1(){
}
Phone1(int price,String brand){
this.brand=brand;
this.price=price;
}
public void setPrice(int price){
this.price=price;
}
public int getPrice(){
return this.price;
}
public void setBrand(String brand){
this.brand=brand;
}
public String getBrand(){
return this.brand;
}
public void show(){
System.out.println("价格是"+price+",品牌是"+brand);
}
}
public class StructureDemo2 {
public static void main(String[] args) {
Phone1 phone1 = new Phone1();
phone1.setPrice(8888);
phone1.setBrand("小米");
phone1.show();
}
}
这个是有参构造方法赋值
package com.shujia.day6;
class Phone1{
private int price;
private String brand;
Phone1(){
}
Phone1(int price,String brand){
this.brand=brand;
this.price=price;
}
public void setPrice(int price){
this.price=price;
}
public int getPrice(){
return this.price;
}
public void setBrand(String brand){
this.brand=brand;
}
public String getBrand(){
return this.brand;
}
public void show(){
System.out.println("价格是"+price+",品牌是"+brand);
}
}
public class StructureDemo2 {
public static void main(String[] args) {
Phone1 phone1 = new Phone1(9999,"xiaomi");
// phone1.setPrice(8888);
// phone1.setBrand("小米");
phone1.show();
}
}
如果是只获取不赋值,可以把setXxx函数去除
5.几种成员方法
package com.shujia.day6;
class Phone2{
public void func1(){
System.out.println("这是无参无返回值的成员方法");
}
public void func2(String s){
System.out.println("这是有参无返回值的成员方法");
}
public String func3(){
System.out.println("这是无参有返回值的成员方法");
return "无参有返回值";
}
public String func4(String s){
System.out.println("这是有参有返回值的成员方法"+s);
return s;
}
}
public class FunctionDemo1 {
public static void main(String[] args) {
Phone2 phone2 = new Phone2();
//无参无返回值的成员方法直接调用即可
phone2.func1();
//有参无返回值的成员方法赋值调用
phone2.func2("hello");
//无参有返回值的成员方法,如果想返回一个值的话 先定义一个变量介绍,或者直接打印这个方法
String s1=phone2.func3();//定义变量接受
System.out.println(phone2.func3());//直接打印这个成员方法
//有参有返回值的成员方法,先要进行赋值,如果想返回一个值的话 先定义一个变量介绍,或者直接打印这个方法
String s2=phone2.func4("nihao");//定义变量接受
System.out.println(phone2.func4("nihao"));//直接打印这个成员方法
System.out.println(s1);
System.out.println(s2);
}
}
6.类的初始化过程
加载Student.class文件进内存
在栈内存为s开辟空间
在堆内存为学生对象开辟空间
对学生对象的成员变量进行默认初始化
对学生对象的成员变量进行显示初始化
通过构造方法对学生对象的成员变量赋值
学生对象初始化完毕,把对象地址赋值给s变量
7.static关键字
7.1相关知识
1.可以修饰成员变量和成员方法
2.static关键字特点
a.随着类的加载而加载
b.优先于对象存在(不需要创建对象就可以输出静态方法)
c.被类的所有对象共享
d.可以通过类名调用
3.static关键字注意事项
a.在静态方法中是没有this关键字的,以及后面的super关键字
b. 静态方法只能访问静态的成员变量和静态的成员方法(类变量)
package com.shujia.day6;
class Person{
private String name;
private int age;
private static String guoJi;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person(String name, int age, String guoJi) {
this.name = name;
this.age = age;
this.guoJi = guoJi;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGuoJi() {
return guoJi;
}
public void setGuoJi(String guoJi) {
this.guoJi = guoJi;
}
public void show(){
System.out.println("姓名是"+name+",年龄是"+age+",国家是"+guoJi);
}
}
public class StaticDemo1 {
public static void main(String[] args) {
// Person person = new Person();
// person.setAge(18);
// person.setName("李四");
// person.setGuoJi("中国");
// person.show();
Person person1 = new Person("李四",18,"中国");
Person person2 = new Person("王五",18);
Person person3 = new Person("张三",20);
person1.show();
person2.show();
person3.show();
}
}
7.2成员变量被static修饰的
1.被static修饰的成员优先对象而存在于方法区中的静态区,并且有个默认值
package com.shujia.day6;
class Person{
private String name;
private int age;
private static String guoJi;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person(String name, int age, String guoJi) {
this.name = name;
this.age = age;
this.guoJi = guoJi;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGuoJi() {
return guoJi;
}
public void setGuoJi(String guoJi) {
this.guoJi = guoJi;
}
public void show(){
System.out.println("姓名是"+name+",年龄是"+age+",国家是"+guoJi);
}
}
public class StaticDemo1 {
public static void main(String[] args) {
Person person1 = new Person("李四",18,"中国");
Person person2 = new Person("王五",18);
Person person3 = new Person("张三",20);
person1.show();
person2.show();
person3.show();
/*运行结果
姓名是李四,年龄是18,国家是中国
姓名是王五,年龄是18,国家是中国
姓名是张三,年龄是20,国家是中国
*/
}
}
2.被static修饰的成员叫做类成员,将来可以直接使用类名进行访问,类名.类成员
package com.shujia.day6;
class Person{
private String name;
private int age;
static String guoJi;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person(String name, int age, String guoJi) {
this.name = name;
this.age = age;
this.guoJi = guoJi;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGuoJi() {
return guoJi;
}
public void setGuoJi(String guoJi) {
this.guoJi = guoJi;
}
public void show(){
System.out.println("姓名是"+name+",年龄是"+age+",国家是"+guoJi);
}
}
public class StaticDemo1 {
public static void main(String[] args) {
Person person1 = new Person("李四",18,"中国");
Person person2 = new Person("王五",18);
Person person3 = new Person("张三",20);
person1.show();
person2.show();
person3.show();
System.out.println(Person.guoJi);
/*运行结果
姓名是李四,年龄是18,国家是中国
姓名是王五,年龄是18,国家是中国
姓名是张三,年龄是20,国家是中国
中国
*/
}
}
7.3静态成员方法
1.非静态的成员方法,既可以访问非静态的成员变量,也可以访问静态的成员变量
package com.shujia.day6;
class Demo2{
static int a=2;
int b=3;
public void show(){
System.out.println(a);
System.out.println(b);
}
}
public class StaticDemo2 {
public static void main(String[] args) {
Demo2 demo2 = new Demo2();
demo2.show();
// 运行结果 2 3
}
}
2.静态的成员方法,只能访问静态的成员变量/静态的成员方法
a.成员变量
package com.shujia.day6;
class Demo2{
static int a=2;
int b=3;
public void show(){
System.out.println(a);
System.out.println(b);
}
public static void show1(){
System.out.println(a);
// System.out.println(b); 报错因为b是非静态成员变量,静态方法无法访问
}
}
public class StaticDemo2 {
public static void main(String[] args) {
Demo2 demo2 = new Demo2();
// demo2.show();
demo2.show1(); //2
Demo2.show1();//2
}
}
b.成员方法
package com.shujia.day6;
class Demo2{
static int a=2;
int b=3;
public void show(){
System.out.println(a);
System.out.println(b);
}
public static void fun(){
System.out.println("这是静态成员方法");
}
public static void show1(){
System.out.println(a);
// System.out.println(b); 报错因为b是非静态成员变量,静态方法无法访问
// show();报错因为show是非静态方法,静态方法无法调用
fun(); //运行结果 这是静态成员方法
}
}
public class StaticDemo2 {
public static void main(String[] args) {
Demo2 demo2 = new Demo2();
// demo2.show();
demo2.show1(); //2
Demo2.show1();//2
}
}
7.4main函数是静态函数
1.public 被jvm调用,访问权限足够大。
static 被jvm调用,不用创建对象,直接类名访问
void被jvm调用,不需要给jvm返回值
main 一个通用的名称,虽然不是关键字,但是被jvm识别
String[] args 以前用于接收键盘录入的
2.在main函数里面的方法只能是静态的
8.文档注释
1.工具类
1、构造方法私有化
2、方法必须是静态
下面就是一个工具类
package com.shujia.day6;
public class ToolDemo1 {
public ToolDemo1() {
}
public static void printArray(int[] arr) {
for (int index = 0; index < arr.length; index++) {
if (index == 0) {
System.out.print("[" + arr[index] + ",");
} else if (index == arr.length - 1) {
System.out.println(arr[index] + "]");
} else {
System.out.print(arr[index] + ",");
}
}
}
}
这个是调用工具类
package com.shujia.day6;
public class JiSuanDemo1 {
public static void main(String[] args) {
int[] arr={11,22,334,55};
ToolDemo1.printArray(arr);
}
}
2.相关注释意思
1.@author 作者
2.@param arr 解锁这段代码的用处
package com.shujia.day06;
/**
* @author 小虎
* @version v1.0.0
* 该类是数加小虎写的专门针对数组做操作的工具类,可以对数组进行逆序,排序,打印数据,获取数组最大值,最小值等等
*/
public class ArrayTool {
private ArrayTool(){}
/**
* 可以对一个元素类型为int类型的一维数组进行打印
* 以指定的格式输出
* 举例:
* 输出:[2,3,1,5,6]
* @param arr 传入一个元素类型为int类型的一维数组
*/
public static void printArray(int[] arr) {
for (int index = 0; index < arr.length; index++) {
if (index == 0) {
System.out.print("[" + arr[index] + ",");
} else if (index == arr.length - 1) {
System.out.println(arr[index] + "]");
} else {
System.out.print(arr[index] + ",");
}
}
}
/**
* 对一个元素类型为int类型的一维数组进行冒泡排序
* @param arr 传入一个元素类型为int类型的一维数组
* @return 返回一个排序后的数组,元素从小到大排序
*/
public static int[] BubbleSort(int[] arr){
for(int i=0;i<arr.length-1;i++){ // 控制轮次
for(int j=0;j<arr.length-i-1;j++){ // 控制每一轮的比较次数
if(arr[j]>arr[j+1]){
int tmp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
}
}
}
return arr;
}
/**
* 对一个元素类型为int类型的一维数组进行逆序
* @param arr 传入一个元素类型为int类型的一维数组
* @return 返回逆序后的数组
*/
public static int[] niXu(int[] arr){
for (int start = 0, end = arr.length - 1; start < end; start++, end--) {
int tmp = arr[start];
arr[start] = arr[end];
arr[end] = tmp;
}
return arr;
}
/**
* 从一个元素类型为int类型的一维数组获取最大值
* @param arr 传入一个元素类型为int类型的一维数组
* @return 返回一个最大值
*/
public static int getMaxNumber(int[] arr){
//1、默认第一个元素为最大值和最小值
int maxNumber = arr[0];
//2、从第二个元素开始依次遍历,与最大值和最小值进行比较
for (int i = 1; i < arr.length; i++) {
if (arr[i] > maxNumber) {
maxNumber = arr[i];
}
}
return maxNumber;
}
/**
* 从一个元素类型为int类型的一维数组获取最小值
* @param arr 传入一个元素类型为int类型的一维数组
* @return 返回一个最大值
*/
public static int getMinNumber(int[] arr){
//1、默认第一个元素为最大值和最小值
int minNumber = arr[0];
//2、从第二个元素开始依次遍历,与最大值和最小值进行比较
for (int i = 1; i < arr.length; i++) {
if (arr[i] < minNumber) {
minNumber = arr[i];
}
}
return minNumber;
}
}
9.代码块
1概念
使用大括号将代码括起来的整体,叫做代码块
2.分类
1.局部代码块
a.概念:将{}括起来的整体,在方法的内部定义,叫做局部代码块,在同一个方法中多个局部代码块的执行顺序是自上而下执行
b.运行关系
1'单个代码块
package com.shujia.day6;
public class CodeDemo1 {
public static void main(String[] args) {
//局部代码块
{
int a=10;
int b=20;
System.out.println(a+b); //30
}
}
}
2'再代码块前面赋值
package com.shujia.day6;
public class CodeDemo1 {
public static void main(String[] args) {
int a=100;
//局部代码块
{
int a=10; //这里出现错误是因为代码块前面已经给a赋值过了,且没有运行出去,这里改变不了a的值
int b=20;
System.out.println(a+b);
}
}
}
3'在代码块后面赋值
package com.shujia.day6;
public class CodeDemo1 {
public static void main(String[] args) {
// int a=100;
//局部代码块
{
int a=10;
int b=20;
System.out.println(a+b); //30
}
int a=100; //这里可以赋值是因为代码块里面的数值已经运行过了,在内存中已经释放了
System.out.println(a); //100
}
}
4'多个代码块运行从上往下
2.构造代码块:
将{}括起来的整体,在类中方法外定义,叫做构造代码块 构造代码块 --> 构造方法
构造代码块,在每次创建对象的时候调用
1.创建对象时候调用
package com.shujia.day6;
class Code{
{
int a=60;
System.out.println(60);
}
}
public class CodeDemo1 {
public static void main(String[] args) {
// int a=100;
//局部代码块
{
int a=10;
int b=20;
System.out.println(a+b); //30
}
int a=100;
System.out.println(a); //100
Code code = new Code(); //60
}
}
2.优先与构造方法先执行
package com.shujia.day6;
class Code{
{
int a=60;
System.out.println(60);
}
public Code() {
System.out.println("这是构造方法");
}
}
public class CodeDemo1 {
public static void main(String[] args) {
// int a=100;
//局部代码块
{
int a=10;
int b=20;
System.out.println(a+b); //30
}
int a=100;
System.out.println(a); //100 这是构造方法
Code code = new Code();
}
}
3.静态代码块:
将{}括起来的整体,在大括号前面加上static关键字,在类中方法外定义,叫做静态代码块
静态代码块--> 构造代码块 --> 构造方法
1.优先对象存在(不需要创建对象即可使用)
package com.shujia.day6;
public class CodeDemo1 {
{
int a=60;
System.out.println(60);
}
public CodeDemo1() {
System.out.println("这是构造方法");
}
static {
System.out.println("这是静态代码块");
}
public static void main(String[] args) {
}
}
//运行结果 这是静态代码块
2.静态代码块,在类加载的时候,就会执行一次,且只会在程序运行开始前运行一次,后续不会运行
package com.shujia.day6;
public class CodeDemo1 {
{
int a=60;
System.out.println(60);
}
public CodeDemo1() {
System.out.println("这是构造方法");
}
static {
System.out.println("这是静态代码块");
}
public static void main(String[] args) {
CodeDemo1 codeDemo1 = new CodeDemo1();
CodeDemo1 codeDemo2 = new CodeDemo1();
}
}
/*
运行结果
这是静态代码块
60
这是构造方法
60
这是构造方法
*/
3.静态代码块--> 构造代码块 --> 构造方法
package com.shujia.day6;
public class CodeDemo1 {
{
int a=60;
System.out.println(60);
}
public CodeDemo1() {
System.out.println("这是构造方法");
}
static {
System.out.println("这是静态代码块");
}
public static void main(String[] args) {
//局部代码块
{
int a=10;
int b=20;
System.out.println(a+b);
}
int a=100;
System.out.println(a);
//
// Code code = new Code();
CodeDemo1 codeDemo1 = new CodeDemo1();
}
}
/*
运行结果
这是静态代码块
30
100
60
这是构造方法
*/
分析 从main开始,优先静态代码块,所以输出"这是静态代码块"。紧接着局部代码块(从上往下执行),输出30,由接着普通语句输出100,后来new出来了一个对象,这个时候先执行构造代码块,输出60,然后执行构造方法,输出"这是构造方法"