JAVA学习11/07——main 方法、代码块、关键字final

最新推荐文章于 2022-03-25 20:38:35 发布

常存存存存

最新推荐文章于 2022-03-25 20:38:35 发布

阅读量164

点赞数

文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_41746080/article/details/121197662

版权

main 方法

main()方法的使用说明
1.main()方法作为程序的入口;
2.main()方法也是一个普通的静态方法
3.main()方法也可以作为我们与控制台交互的方式。(之前，使用 Scanner)

令行参数用法举例

public class MainDemo {
	public static void main(String[] args) {
		
		for(int i = 0;i < args.length;i++){
			System.out.println("/*/*/*/"+ args[i]);
		}	
	}
}

运行程序 MainDemo.java

javac MainDemo.java
java MainDemo “Tom” “Jerry” “Shkstart”

在这里插入图片描述

类的成员之四：代码块

1.代码块的作用：用来初始化类、对象的
2.代码块如果有修饰的话，只能使用 static
3.分类:静态代码块 vs 非静态代码块
4.静态代码块
》内部可以有输出语句
》随着类的加载而执行,而且只执行一次
》作用:初始化类的信息
》如果一个类中，定义了多个静态代码块，则按照声明的先后顺序执行
》静态代码块的执行，优先于非静态代码块的执行
》静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构
5.非静态代码块
》内部可以有输出语句
》随着对象的创建而执行
》每创建一个对象，就执行一次非静态代码块。
》作用:可以在创建对象时，对对象的属性等进行初始化。
》如果一个类中，定义了多个非静态代码块，则按照声明的先后顺序执行
》非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法。
对属性可以赋值的位置:
①默认初始化
②显式初始化
③构造器中初始化
④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值。
⑤在代码块中赋值

public class BlockTest {
	public static void main(String[] args) {
		
		String desc = Person.desc;
		System.out.println(desc);
		
		Person p1 = new Person();
		Person p2 = new Person();
		System.out.println(p1.age);
		
		Person.info();
	}
}

class Person{
	//属性
	String name;
	int age;
	static String desc = "我是一个青年";
	
	//构造器
	public Person(){
		
	}
	
	//static 的代码块
	static{
		System.out.println("hello,static block-1");
		//调用静态结构
		desc = "我是一个爱小说的人";
		info();
		//不能调用非静态结构
//		eat();
//		name = "Tom";
	}
	
	static{
		System.out.println("hello,static block-2");
	}
	
	//非 static 的代码块
	{
		System.out.println("hello,block-2");
	}
	{
		System.out.println("hello,block-1");
		//调用非静态结构
		age = 1;
		eat();
		//调用静态结构
		desc = "我是一个爱小说的人 1";
		info();
	}	
	
	//方法
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	
	public void eat(){
		System.out.println("吃饭");
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	public static void info(){
		System.out.println("我是一个快乐的人。");
	}
	
}

举例
//总结:由父类到子类，静态先行

class Root{
	static{
		System.out.println("Root 的静态初始化块");
	}
	{
		System.out.println("Root 的普通初始化块");
	}
	public Root(){
		System.out.println("Root 的无参数的构造器");
	}
}
class Mid extends Root{
	static{
		System.out.println("Mid 的静态初始化块");
	}
	{
		System.out.println("Mid 的普通初始化块");
	}
	public Mid(){
		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(); 
		//new Leaf();
	}
}

在这里插入图片描述

静态初始化块举例 2

class Father {
	static {
		System.out.println("11111111111");
	}
	{
		System.out.println("22222222222");
	}

	public Father() {
		System.out.println("33333333333");

	}

}

public class Son extends Father {
	static {
		System.out.println("44444444444");
	}
	{
		System.out.println("55555555555");
	}
	public Son() {
		System.out.println("66666666666");
	}

	public static void main(String[] args) { // 由父及子 静态先行
		System.out.println("77777777777");
		System.out.println("************************");
		new Son();
		System.out.println("************************");

		new Son();
		System.out.println("************************");
		new Father();
	}

}

在这里插入图片描述
程序中成员变量赋值的执行顺序

对属性可以赋值的位置:
①默认初始化
②显式初始化 / ⑤在代码块中赋值
③构造器中初始化
④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值。

执行的先后顺序:① - ② / ⑤ - ③ - ④

public class OrderTest {
	public static void main(String[] args) {
		Order order = new Order();
		System.out.println(order.orderId);4
		Order1 order1 = new Order1();
		System.out.println(order1.orderId);3
	}
}
class Order{
	
	int orderId = 3;
	{
		orderId = 4;
	}
	
}
class Order1{
	{
		orderId = 4;
	}
	int orderId = 3;
	
	
}

关键字：final

final:最终的
1.final可以用来修饰的结构:类、方法、变量
2.final用来修饰一个类:此类不能被其他类所继承。
比如:String类、System类、StringBuffer类
3.final修饰一个方法:final标记的方法不能被子类重写。
比如：Object类中的getClass()。
4.final用来修饰变量:此时的"变量"(成员变量或局部变量)就是一个常量。名称大写，且只能被赋值一次。
4.1 final修饰属性，可以考虑赋值的位置有:显式初始化、代码块中初始化、构造器中初始化
4.2 final修饰局部变量:尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。
一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。
static final 用来修饰:全局常量

public class FinalTest {
	
	final int WIDTH = 0;
	final int LEFT;
	final int RIGHT;
//	final int DOWN;
	
	{
		LEFT = 1;
	}
	
	public FinalTest(){
		RIGHT = 2;
	}
	
	public FinalTest(int n){
		RIGHT = n;
	}
	
//	public void setDown(int down){
//		this.DOWN = down;
//	}
	
	public void dowidth(){
//		width = 20;	//width cannot be resolved to a variable
	}
	
	public void show(){
		final int NUM = 10;	//常量
//		num += 20;
	}
	
	public void show(final int num){
		System.out.println(num);
	}
	
	public static void main(String[] args) {
		
		int num = 10;
		
		num = num + 5;
		
		FinalTest test = new FinalTest();
//		test.setDown(5);
		
		test.show(10);
	}
}

final class FianlA{
	
}

//class B extends FinalA{     //错误，不能被继承。
//	
//}

//class C extends String{
//	
//}

class AA{
	public final void show(){
		
	}
}

//class BB extends AA{	// 错误，不能被重写。
//	public void show(){
//		
//	}
//}

1、面试题

public class Something {
	public int addOne(final int x) {
		return ++x; //错误
		// return x + 1;//正确，x未改变
	}
}

2、面试题2

public class Something {

	public static void main(String[] args) {
		Other o = new Other();
		new Something().addOne(o);
	}

	public void addOne(final Other o) {
		// o = new Other();
		o.i++; //能够运行，o没有改变，但是o,i可以改变
	}
}

class Other {
	public int i;
}

常存存存存

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA学习11/07——main 方法、代码块、关键字final

main 方法main()方法的使用说明1.main()方法作为程序的入口;2.main()方法也是一个普通的静态方法3.main()方法也可以作为我们与控制台交互的方式。(之前，使用 Scanner)令行参数用法举例public class MainDemo { public static void main(String[] args) { for(int i = 0;i < args.length;i++){ System.out.println("/*/*
复制链接

扫一扫