package com.atguigu.java1; /* * static关键字的使用 * * 1.static:静态的 * 2.static可以用来修饰：属性、方法、代码块、内部类 * * 3.使用static修饰属性：静态变量（或类变量） * 3.1 属性，按是否使用static修饰，又分为：静态属性 vs 非静态属性(实例变量) * 实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的 * 非静态属性时，不会导致其他对象中同样的属性值的修改。 * 静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致 * 其他对象调用此静态变量时，是修改过了的。 * 3.2 static修饰属性的其他说明： * ① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用 * ② 静态变量的加载要早于对象的创建。 * ③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。 * * ④ 类变量 实例变量 * 类 yes no * 对象 yes yes * * 3.3 静态属性举例：System.out; Math.PI; * * 4.使用static修饰方法：静态方法 * ① 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用 * ② 静态方法 非静态方法 * 类 yes no * 对象 yes yes * ③ 静态方法中，只能调用静态的方法或属性 * 非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性 * * 5. static注意点： * 5.1 在静态的方法内，不能使用this关键字、super关键字 * 5.2 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。 * * 6. 开发中，如何确定一个属性是否要声明为static的？ * > 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。 * > 类中的常量也常常声明为static * * 开发中，如何确定一个方法是否要声明为static的？ * > 操作静态属性的方法，通常设置为static的 * > 工具类中的方法，习惯上声明为static的。 比如：Math、Arrays、Collections */ public class StaticTest { public static void main(String[] args) { Chinese.nation = "中国"; Chinese c1 = new Chinese(); c1.name = "姚明"; c1.age = 40; c1.nation = "CHN"; Chinese c2 = new Chinese(); c2.name = "马龙"; c2.age = 30; c2.nation = "CHINA"; System.out.println(c1.nation); //编译不通过 // Chinese.name = "张继科"; c1.eat(); Chinese.show(); //编译不通过 // Chinese.eat(); // Chinese.info(); } } //中国人 class Chinese{ String name; int age; static String nation; public void eat(){ System.out.println("中国人吃中餐"); //调用非静态结构 this.info(); System.out.println("name :" +name); //调用静态结构 walk(); System.out.println("nation : " + nation); } public static void show(){ System.out.println("我是一个中国人！"); //不能调用非静态的结构 // eat(); // name = "Tom"; //可以调用静态的结构 System.out.println(Chinese.nation); walk(); } public void info(){ System.out.println("name :" + name +",age : " + age); } public static void walk(){ } }
package com.atguigu.java1; public class ArrayUtilTest { public static void main(String[] args) { // ArrayUtil util = new ArrayUtil(); int[] arr = new int[]{32,34,32,5,3,54,654,-98,0,-53,5}; int max = ArrayUtil.getMax(arr); System.out.println("最大值为：" + max); System.out.println("排序前："); ArrayUtil.print(arr); ArrayUtil.sort(arr); System.out.println("排序后："); ArrayUtil.print(arr); // System.out.println("查找："); // int index = util.getIndex(arr, -5); // if(index >= 0){ // System.out.println("找到了，索引地址为：" + index); // }else{ // System.out.println("未找到"); // } // util.reverse(arr); } }
package com.atguigu.java1; /* * 自定义数组的工具类 * */ public class ArrayUtil { // 求数组的最大值 public static int getMax(int[] arr) { int maxValue = arr[0]; for (int i = 1; i < arr.length; i++) { if (maxValue < arr[i]) { maxValue = arr[i]; } } return maxValue; } // 求数组的最小值 public static int getMin(int[] arr) { int minValue = arr[0]; for (int i = 1; i < arr.length; i++) { if (minValue > arr[i]) { minValue = arr[i]; } } return minValue; } // 求数组的总和 public static int getSum(int[] arr) { int sum = 0; for (int i = 0; i < arr.length; i++) { sum += arr[i]; } return sum; } // 求数组的平均值 public static int getAvg(int[] arr) { return getSum(arr) / arr.length; } //如下的两个同名方法构成了重载 // 反转数组 public static void reverse(int[] arr) { for (int i = 0; i < arr.length / 2; i++) { int temp = arr[i]; arr[i] = arr[arr.length - i - 1]; arr[arr.length - i - 1] = temp; } } // public static void reverse(String[] arr){ // // } // 复制数组 public static int[] copy(int[] arr) { int[] arr1 = new int[arr.length]; for (int i = 0; i < arr1.length; i++) { arr1[i] = arr[i]; } return arr1; } // 数组排序 public static void sort(int[] arr) { // 冒泡排序 for (int i = 0; i < arr.length - 1; i++) { for (int j = 0; j < arr.length - 1 - i; j++) { if (arr[j] > arr[j + 1]) { // int temp = arr[j]; // arr[j] = arr[j + 1]; // arr[j + 1] = temp; //错误的： // swap(arr[j],arr[j + 1]); //正确的： swap(arr,j,j + 1); } } } } //错误的：交换数组中指定两个位置元素的值 // public void swap(int i,int j){ // int temp = i; // i = j; // j = temp; // } //正确的：交换数组中指定两个位置元素的值 private static void swap(int[] arr,int i,int j){ int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } // 遍历数组 public static void print(int[] arr) { for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); } System.out.println(); } // 查找指定元素 public static int getIndex(int[] arr, int dest) { // 线性查找： for (int i = 0; i < arr.length; i++) { if (dest == arr[i]) { return i; } } return -1;//返回一个负数，表示没有找到 } }
package com.atguigu.java1; //static关键字的应用 public class CircleTest { public static void main(String[] args) { Circle c1 = new Circle(); Circle c2 = new Circle(); Circle c3 = new Circle(3.4); System.out.println("c1的id：" + c1.getId() ); System.out.println("c2的id：" + c2.getId() ); System.out.println("c3的id：" + c3.getId() ); System.out.println("创建的圆的个数为：" + Circle.getTotal()); } } class Circle{ private double radius; private int id;//自动赋值 public Circle(){ id = init++; total++; } public Circle(double radius){ this(); // id = init++; // total++; this.radius = radius; } private static int total;//记录创建的圆的个数 private static int init = 1001;//static声明的属性被所有对象所共享 public double findArea(){ return 3.14 * radius * radius; } public double getRadius() { return radius; } public void setRadius(double radius) { this.radius = radius; } public int getId() { return id; } public static int getTotal() { return total; } }
package com.atguigu.exer; /* * 编写一个类实现银行账户的概念，包含的属性有“帐号”、“密码”、“存款余额”、“利率”、“最小余额”， * 定义封装这些属性的方法。账号要自动生成。 编写主类，使用银行账户类，输入、输出3个储户的上述信息。 考虑：哪些属性可以设计成static属性。 * * */ public class Account { private int id; private String pwd = "000000"; private double balance; private static double interestRate; private static double minMoney = 1.0; private static int init = 1001;//用于自动生成id使用的 public Account(){ id = init++; } public Account(String pwd,double balance){ id = init++; this.pwd = pwd; this.balance = balance; } public String getPwd() { return pwd; } public void setPwd(String pwd) { this.pwd = pwd; } public static double getInterestRate() { return interestRate; } public static void setInterestRate(double interestRate) { Account.interestRate = interestRate; } public static double getMinMoney() { return minMoney; } public static void setMinMoney(double minMoney) { Account.minMoney = minMoney; } public int getId() { return id; } public double getBalance() { return balance; } @Override public String toString() { return "Account [id=" + id + ", pwd=" + pwd + ", balance=" + balance + "]"; } }
package com.atguigu.exer; public class AccountTest { public static void main(String[] args) { Account acct1 = new Account(); Account acct2 = new Account("qwerty",2000); Account.setInterestRate(0.012); Account.setMinMoney(100); System.out.println(acct1); System.out.println(acct2); System.out.println(acct1.getInterestRate()); System.out.println(acct1.getMinMoney()); } }
package com.atguigu.java2; /* * 单例设计模式： * 饿汉式单例模型 * 1.所谓的单例设计模式，就是采取一定的方法保证整个的软件系统中，对某个类只能存在一个对象实例。 * * 2.如何实现？ * 饿汉式 VS 懒汉式 * * 3.区分饿汉式 和 懒汉式 * 饿汉式： * 坏处：对象加载时间过长。 * 好处：饿汉式是线程安全的 * * 懒汉式： * 好处：延迟对象的创建。 * 目前的写法坏处：线程不安全。--->多线程内容中修改 * * * */ public class SingletonTest1 { public static void main(String[] args) { // Bank bank1 = new Bank(); //The constructor Bank() is not visible Bank bank1 = Bank.getInstance(); Bank bank2 = Bank.getInstance(); System.out.println(bank1 == bank2); //true 地址值一样说明只有一个实例对象 } } //饿汉式单例模型 class Bank{ //私有化类的构造器 private Bank(){ } //2.内部创建类的对象 //4.要求此对象必须声明为静态的 private static Bank instance = new Bank(); //3.提供公共的静态方法，返回类的对象 public static Bank getInstance(){ return instance; } }
package com.atguigu.java2; /* * 单例模式的懒汉式实现 * */ public class SingletonTest2 { public static void main(String[] args) { Order order1 = Order.getInstance(); Order order2 = Order.getInstance(); System.out.println(order1 == order2); } } class Order{ //1.私有化类的构造器 private Order(){ } //2.声明当前类对象，没有初始化 //4.此对象也必须声明为static的 private static Order instance = null; //3.声明public、static的返回当前类对象的方法 public static Order getInstance(){ if(instance == null){ instance = new Order(); } return instance; } }
package com.atguigu.java2; /* * main()方法的使用说明： * 1. main()方法作为程序的入口 * 2. main()方法也是一个普通的静态方法 * 3. main()方法可以作为我们与控制台交互的方式。（之前：使用Scanner） * * * */ public class MainTest { public static void main(String[] args) {//入口 Main.main(new String[100]); MainTest test = new MainTest(); test.show(); } public void show(){ } } class Main{ public static void main(String[] args) { for(int i = 0;i < args.length;i++){ args[i] = "args_" + i; System.out.println(args[i]); } } }
package com.atguigu.java2; public class MainDemo { public static void main(String[] args) { for(int i = 0;i < args.length;i++){ System.out.println("*****" + args[i]); int num = Integer.parseInt(args[i]); System.out.println("#####" + num); } } }
package com.atguigu.java3; /* * 类的成员之四：代码块（或初始化块） * * 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(){ } 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-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("我是一个快乐的人！"); } }
package com.atguigu.java3; //总结：由父及子，静态先行 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的构造器 */
package com.atguigu.java3; 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(); } } /* 11111111111 44444444444 77777777777 ************************ 22222222222 33333333333 55555555555 66666666666 ************************ 22222222222 33333333333 55555555555 66666666666 ************************ 22222222222 33333333333 */
package com.atguigu.java3; /* * 对属性可以赋值的位置： * ①默认初始化 * ②显式初始化/⑤在代码块中赋值 * ③构造器中初始化 * ④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值 * * * 执行的先后顺序：① - ② / ⑤ - ③ - ④ */ public class OrderTest { public static void main(String[] args) { Order order = new Order(); System.out.println(order.orderId); } } class Order{ int orderId = 3; { orderId = 4; } }
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 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; } public void show(){ final int NUM = 10;//常量 // NUM += 20; } public void show(final int num){ // num = 20;//编译不通过 System.out.println(num); } public static void main(String[] args) { int num = 10; num = num + 5; FinalTest test = new FinalTest(); // test.setDown(3); test.show(10); } } final class FinalA{ } //class B extends FinalA{ // //} //class C extends String{ // //} class AA{ public final void show(){ } } class BB extends AA{ // public void show(){ //Cannot override the final method // // } }
