理解main（）方法的语法
package com.atguigu.java2;
/*
* main()方法的使用说明：
* 1. main()方法作为程序的入口
* 2. main()方法也是一个普通的静态方法
* 3. main()方法可以作为我们与控制台交互的方式。（之前：使用Scanner）
*/
public class MainTest {
//下一句public static void main(String[] args)使用public是使得
//范围尽可能的大，java虚拟机调用main（）方法时，如果main（）方法权限过小，
//MainTest.main()可能点不出来，调不了，运行不了。
public static void main(String[] args) {//入口
//静态main（）方法里调静态方法（Main.main（））
Main.main(new String[100]);
//非静态方法show()需要用对象调，所以new MainTest();
MainTest test = new MainTest();
test.show();
}
public void show(){
}
}
class Main{
//一个源文件中只能声明一个public的类，但是没说只能声明一个main（）方法
public static void main(String[] args) {
for(int i = 0;i < args.length;i++){
args[i] = "args_" + i;
System.out.println(args[i]);
}
}
}
main()方法可以作为我们与控制台交互的方式。（之前：使用Scanner）
1、用例代码
public class MainDemo {
public static void main(String[] args) {
for(int i = 0;i < args.length;i++){
System.out.println("*****" + args[i]);
//以下 可 将String类型转换为int型
int num = Integer.parseInt(args[i]);
System.out.println("#####" + num);
}
}
}
2、传参步骤
2.1 idea操作方法
往String [] arge里传参，先编译，再点编辑配置。
再在程序参数那填 想填的参数（String 类型加不加引号都可以）
最后运行
结果：
2.2 命令行操作方法
类中代码块结构的使用
package com.atguigu.java3;
/*
* 类的成员之四：代码块（或初始化块）
*
* 1. 代码块的作用：用来初始化类、对象
* 2. 代码块如果有修饰的话，只能使用static.
* 代码块只有
* static{
* }
* 或
* {
* } 两种。
*
* 3. 分类：静态代码块 vs 非静态代码块
*
* 4. 静态代码块
* >内部可以有输出语句
* >随着 类 的加载而执行,而且只 执行 一次
* （静态方法需要对象或类 点去调才能执行，而代码块我们是不能主动的去调用代码块的，代码块通常都是自动执行的，静态代码块是随着加载而执行的）
* >作用：初始化类的信息
* >如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
* >静态代码块的执行要优先于非静态代码块的执行，（因为类一加载就能执行静态代码块了，非静态代码块要造对象后才能执行。）
* >静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构
*
* 5. 非静态代码块
* >内部可以有输出语句
* >随着 对象 的创建而 执行
* >每创建一个对象，就执行一次非静态代码块
* >作用：可以在创建对象时，对 对象的属性等进行初始化
* >如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
* >非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法
*
* 注：一般没必要写多个代码块，直接合成一个就行了。一般也不怎么用代码块，一般看源码用。
*/
public class BlockTest {
public static void main(String[] args) {
String desc = Person.desc;//当你使用一个类时，类就会加载，意味着静态的就都会加载进内存
//↑此处加载了类，输出hello，static block。静态代码块随着类的加载而执行,而且只 执行 一次。
//之后由于又写了一个静态代码块，并将hello，static block改成了hello，static block1。并加了个
//hello，static block2，这两个静态代码块按从前往后的顺序执行，依次输出
// hello,static block-2
// hello,static block-1
System.out.println(desc);//以下的静态代码块中重新赋值了，desc = "我是一个爱学习的人";
//↑输出 我是一个爱学习的人
Person p1 = new Person();
//↑此处创建了对象，输出hello，block。
//后改为输出hello, block - 2
// hello, block - 1
Person p2 = new Person();
//↑此处创建了对象，输出hello，block。每new一个对象，就运行一次非静态代码块
System.out.println(p1.age);
//↑因为下面的非静态代码块设置了age=1，所以这里输出 1
Person.info();
}
}
class Person{
//属性
String name;
int age;
static String desc = "我是一个人";
//构造器
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
//非static的代码块
{
System.out.println("hello, block - 2");
}
{
System.out.println("hello, block - 1");
//调用非静态结构
age = 1;
eat();
//调用静态结构
desc = "我是一个爱学习的人1";
info();
}
//static的代码块
// static{
// System.out.println("hello,static block");
// }
static{
System.out.println("hello,static block-2");
}
static{
System.out.println("hello,static block-1");
//调用静态结构
desc = "我是一个爱学习的人";
info();
//不可以调用非静态结构
// eat();//非静态方法不能被静态代码块调用
// name = "Tom";//非静态属性不能被静态代码块调用
}
//方法
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(){
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();
}
}
结果
一个例题试练
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
}
}
class Order{
//默认初始化是int orderId;然后默认orderId为0；
int orderId = 3; //显式初始化
{ //代码块赋值
orderId = 4;
}
//在方法中需要先定义，再赋值操作，而类中无先后顺序，类是一个结构。
// 如果代码块在显示初始化的前面，就输出3。
// { //代码块赋值
// orderId = 4;
// }
// int orderId = 3; //显式初始化
}
final关键字
代码知识点总结
package com.atguigu.java3;
/*
* final:最终的
*
* 1. final可以用来修饰的结构：类、方法、变量，意为最终的类，最终的方法、最终的变量。
*
* 2. final 用来修饰一个类:此类不能被其他类所继承。
* 比如：String类、System类、StringBuffer类
*
* 3. final 用来修饰方法：表明此方法不可以被重写
* 比如：Object类中getClass();就是最终方法，不能重写。
*
* 4. final 用来修饰变量：此时的"变量"就称为是一个常量（不能变了，不能改了）
* 4.1 final修饰属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化
* 4.2 final修饰局部变量：
* 尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值
* 以后，就只能在方法体内使用此形参，但不能进行重新赋值。
*
* 如果用static final 来修饰 属性，那这个属性就称为全局常量。
*/
public class FinalTest {
final int WIDTH = 0;//final常量没有默认值，定义时必须手动赋值。
// 如final int WIDTH;会报错
final int LEFT;//代码块中初始化：LEFT不是静态的，所以用非静态代码块赋值，
final int RIGHT;//构造器中初始化，下面有构造器能给RIGHT赋值。
// final int DOWN; //方法去赋值不靠谱，通过方法不可以给final类型赋初值
{
LEFT = 1; //代码块中初始化上述的LEFT
}
//构造器中初始化上述的RIGHT
public FinalTest(){
RIGHT = 2;
}
//每个构造器需要保证所有final的变量都初始化。所以下面两行是非法的。
// public FinalTest(){
// }//因为这个构造器没有初始化RIGHT等final修饰的对象。
public FinalTest(int n){
RIGHT = n;
}
//↓方法去赋值不靠谱，不可以。因为构造器后才会调用方法，
//↓ 而构造器结束后就要告诉系统你的final修饰的属性是什么值了，在调方法就太晚了。
// public void setDown(int down){
// this.DOWN = down;
// }
public void doWidth(){
// WIDTH = 20;//因为前面WIDTH被final修饰了，所以不能改了
}
public void show(){
final int NUM = 10;//常量
// NUM += 20;// 方法体内被final修饰的局部变量不能变了
}
public void show(final int num){//final修饰的形参，在传入实参后，在方法内只能使用，不能修改其值。
// num = 20;//编译不通过
System.out.println(num);
}
//main方法
public static void main(String[] args) {
int num = 10;
num = num + 5;
FinalTest test = new FinalTest();
// test.setDown(3);
test.show(10);//调用了上面final修饰的形参的函数public void show(final int num)
}
}
final class FinalA{
}
//class B extends FinalA{
// 被final修饰的类不能被继承
//}
//class C extends String{
// String类已被声称为final的，所以也不能被继承。
// String类不能被继承，声明为final类型还有个原因是
// 开发人员已经把能用的字符串的方法都写出来了，你在继承添加也没啥有用的方法了，干脆就不让继承了
// 该有的方法都提供了
//}
class AA{
public final void show(){
}
}
class BB extends AA{
// public void show(){
// 用final修饰的方法不能被重写。
// }
}
final笔试题
题1：
return ++x；这个不行，因为它改变x的值了，
return x+1；这个可以，因为它没改变x的值，只是返回了x+1那个数的值。
题2：
这样是对的，final修饰的o ， o别重新赋值就行，i是变量，可以重新赋值。
如果把加入图中绿色 o=new Other();，就出错的，因为相当于重新给 o 赋值了，违背了final。