今日内容介绍
u 知识回顾
u static静态关键字
u 代码块
第1章 知识回顾
1.1 方法的回顾
1.1.1 案例代码一:
package com.itheima_01;
/*
* 需求：定义一个方法求两个数的和,并在主方法中调用
*
* 方法：类中的一段具有特定功能的程序，提高了代码的复用性和可维护性
* 定义格式：
* public static 返回值类型（没有返回值写void） 方法名(参数类型 参数名,参数类型 参数名2) {//形参
* 方法体;
* }
* 调用方式：
* 有明确返回值类型：
* 赋值调用，将方法的返回值赋值给一个变量
* 输出调用，使用输出语句直接输出方法的返回值
* 直接调用，没法获取方法的返回值
* 没有明确返回值类型：
* 直接调用
* 方法重载：在一个类中有多个重名的方法，这些方法参数不同，和返回值无关
*
* 注意：
* 形参：方法声明的变量，只能是变量，接收方法调用时传递进来的数据
* 实参：调用方法时传递的数据，可以是常量也可以是变量
*
*/
public class MethoDemo {
public static void main(String[] args) {
//赋值调用
//int sum = sum(10,20);//实参
//System.out.println(sum);
//输出调用
int a = 10;
int b = 20;
System.out.println(sum(a,b));
}
public static int sum(int a,int b) {
/* //使用变量接收求和结果并返回
int sum = a + b;
return sum;*/
//直接返回求和结果
return a + b;
}
}
1.2 数组的回顾
1.2.1 案例代码二:
package com.itheima_02;
/*
* 需求：定义一个元素类型为int的数组，遍历数组并求和
*
* 数组：用于存储多个元素的一种容器
* 数组的特点:
* 元素类型必须一致
* 元素有整数索引
* 一旦定义好长度则无法改变
* 可以存储基本数据类型
* 也可以存储引用数据类型
* 定义格式：
* 动态初始化
* 元素类型[] 数组名 = new 元素类型[10];
* 静态初始化
* 元素类型[] 数组名 = {元素1,元素2,元素3};
* 元素类型[] 数组名 = new 元素类型[]{元素1,元素2,元素3};
*
*/
public class ArrayDemo {
public static void main(String[] args) {
//使用静态初始化定义数组
int[] arr = {1,2,3,4,5};
//定义一个变量用于存储求和结果
int sum = 0;
//遍历数组
for(int x = 0;x < arr.length;x++) {
sum += arr[x];
}
System.out.println(sum);
}
}
1.3 标准类定义和使用回顾
1.3.1 案例代码三:
package com.itheima_03;
/*
* 定义一个标准的学生类，在主方法中创建对象并调用
* 姓名，年龄，性别3个成员变量
* 无参，有参两个构造方法
* 为每个成员变量定义getter/setter方法
* 定义一个show方法，输出成员变量
*/
public class Student {
private String name;//姓名
private int age;//年龄
private String gender;//性别
/*//无参构造
public Student() {}
//有参构造
public Student(String name,int age,String gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
//name
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//age
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//gender
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}*/
//show：用于输出所有的成员变量
public void show() {
System.out.println(name + "," + age + "," + gender);
}
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int age, String gender) {
super();
this.name = name;
this.age = age;
this.gender = gender;
}
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 getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
}
package com.itheima_03;
public class StudentTest {
public static void main(String[] args) {
//创建学生对象
Student s = new Student();
//为成员变量进行赋值
s.setName("张三");
s.setAge(18);
s.setGender("男");
s.show();
System.out.println("----------");
Student s2 = new Student("李四",20,"其他");
//s2.show();
System.out.println(s2.getName());
}
}
第2章 static静态关键字
2.1 静态的概述
当在定义类的时候，类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。当在调用对象的某个方法时，这个方法没有访问到对象的特有数据时，方法创建这个对象有些多余。可是不创建对象，方法又调用不了，这时就会想，那么我们能不能不创建对象，就可以调用方法呢？
可以的，我们可以通过static关键字来实现。static它是静态修饰符，一般用来修饰类中的成员。
2.2 静态的特点
A: 被static修饰的成员变量属于类，不属于这个类的某个对象。（也就是说，多个对象在访问或修改static修饰的成员变量时，其中一个对象将static成员变量值进行了修改，其他对象中的static成员变量值跟着改变，即多个对象共享同一个static成员变量）
B: 被static修饰的成员可以并且建议通过类名直接访问
访问静态成员的格式:
类名.静态成员变量名
类名.静态成员方法名(参数)
C: 静态的加载优先于对象,随着类的加载而加载
2.2.1 案例代码四
package com.itheima_01;
/*
* static:是一个关键字，用于修饰成员变量和成员方法
* static的特点：
* 被所有的对象所共享
* 可以使用类名调用
* 静态的加载优先于对象
* 随着类的加载而加载
*
*/
public class StaticDemo {
public static void main(String[] args) {
Person.graduateFrom = "传智学院";
Person p = new Person();
p.name = "小苍同学";
p.age = 18;
//p.graduateFrom = "传智学院";
p.speak();
Person p2 = new Person();
p2.name = "小波同学";
p2.age = 20;
//p2.graduateFrom = "传智学院";
p2.speak();
}
}
class Person {
String name;
int age;
static String graduateFrom;//毕业院校
public void speak() {
System.out.println(name + "---" + graduateFrom);
}
}
2.3 静态的注意事项
A:静态成员只能直接访问静态成员
B:非静态成员既可以访问非静态成员也可以访问静态成员
2.3.1 案例代码五
package com.itheima_01;
/*
* static的注意事项：
* 静态方法：
* 可以调用静态的成员变量
* 可以调用静态的成员方法
* 不可以调用非静态成员变量
* 不可以调用非静态成员方法
* 静态方法只能调用静态的成员
* 非静态方法：
* 可以调用静态的成员变量
* 可以调用静态的成员方法
* 可以调用非静态的成员变量
* 可以调用非静态的成员方法
*
* 静态的方法中是否有this这个对象？没有的
*
*
*/
public class StaticDemo2 {
public static void main(String[] args) {
Student.graduateFrom = "传智学院";
Student.study();
}
}
class Student {
String name;
int age;
static String graduateFrom;//毕业院校
public static void study() {
///System.out.println(graduateFrom);
//sleep();
//System.out.println(name);
//eat();
}
public static void sleep() {
System.out.println("sleep");
}
public void eat() {
System.out.println("eat");
System.out.println(graduateFrom);
sleep();
}
}
2.4 静态的优缺点
A:静态优点:
对对象的共享数据提供单独空间的存储，节省空间，没有必要每一个对象都存储一份
可以直接被类名调用,不用在堆内存创建对象
静态成员可以通过类名直接访问,相对创建对象访问成员方便
B:静态弊端:
访问出现局限性。（静态虽好，但只能访问静态）
2.5 静态应用
2.5.1 Math类使用
A:Math 类包含用于执行基本数学运算的方法。数学操作常用的类。
B:Math类的构造方法被private,无法创建对象,也就无法通过对象来访问Math类中的成员
C:Math类中所有的成员都被静态修饰,因此我们可以直接通过类名访问
2.5.1.1 案例代码三:
package com.itheima_02;
public class MathDemo {
public static void main(String[] args) {
//Math:包含了一些基本的数学运算方法
//static double PI
//System.out.println(Math.PI);
//static double abs(double a) :返回绝对值
//System.out.println(Math.abs(15));15
//System.out.println(Math.abs(-10));10
//static double ceil(double a) 天花板 向上取整
//System.out.println(Math.ceil(1.2));2
//System.out.println(Math.ceil(1.6));2
//System.out.println(Math.ceil(-1.6));-1
//static double floor(double a) 地板 向下取整
//System.out.println(Math.floor(1.2));1
//System.out.println(Math.floor(1.6));1
//System.out.println(Math.floor(-1.6));-2
//static long round(double a) ：四舍五入
//System.out.println(Math.round(1.2));1
//System.out.println(Math.round(1.6));2
//static double max(double a, double b)
//System.out.println(Math.max(3, 4));4
//static double pow(double a, double b) :返回第一个参数的第二个参数次幂
//System.out.println(Math.pow(3, 2));8
//static double random() :返回一个随机数，大于零且小于一
System.out.println(Math.random());
}
}
2.5.2 自定义工具类
A:需求:自定义一个专门对数组操作的工具类,具有的功能如下
1.定义一个方法,该方法可以返回数组中最大元素
2.定义一个方法,该方法根据指定的值去数组中查找是否存在该值
存在,返回该值在数组中的索引
不存在,返回-1
2.5.2.1 案例代码四:
package com.itheima_03;
public class MyArrays {
private MyArrays() {}
/*
* 返回数组中最大的元素
*
*/
public static int getMax(int[] arr) {
int max = 0;//参照物
//遍历数组
for(int x = 0;x < arr.length;x++) {
if(arr[x] > max) {
max = arr[x];//替换参照物
}
}
return max;
}
/*
* 返回数组中指定参数的索引
*
*/
public static int getIndex(int[] arr,int a) {
//遍历数组
for(int x = 0;x < arr.length;x++) {
if(arr[x] == a) {
return x;
}
}
return -1;//如果查不到制定的参数，则返回-1
}
}
package com.itheima_03;
public class MyArraysDemo {
public static void main(String[] args) {
int[] arr = {3,5,8,10,1};
int max = MyArrays.getMax(arr);
System.out.println(max);
int index = MyArrays.getIndex(arr, 8);
System.out.println(index);
}
}
2.6 类变量与实例变量辨析
A:类变量:其实就是静态变量
定义位置:定义在类中方法外
所在内存区域:方法区
生命周期:随着类的加载而加载
特点:无论创建多少对象,类变量仅在方法区中,并且只有一份
B:实例变量:其实就是非静态变量
定义位置:定义在类中方法外
所在内存区域:堆
生命周期:随着对象的创建而加载
特点:每创建一个对象,堆中的对象中就有一份实例变量
第3章 代码块
3.1 局部代码块
局部代码块是定义在方法或语句中
3.1.1 案例代码六:
public class BlockDemo {
public static void main(String[] args) {
//局部代码块：存在于方法中，控制变量的生命周期（作用域）
{
for(int x = 0;x < 10;x++) {
System.out.println("我爱Java");
}
int num = 10;
}
//System.out.println(num);//无法访问num,超出num的作用域范围
}
}
3.2 构造代码块
构造代码块是定义在类中成员位置的代码块
3.2.1 案例代码七:
package com.itheima_04;
class Teacher {
String name;
int age;
{
for(int x = 0;x < 10;x++) {
System.out.println("我爱Java");
}
System.out.println("我爱Java");
}
public Teacher() {
System.out.println("我是无参空构造");
}
public Teacher(String name,int age) {
System.out.println("我是有参构造");
this.name = name;
this.age = age;
}
}
3.3 静态代码块
A:静态代码块是定义在成员位置，使用static修饰的代码块
3.3.1 案例代码八:
class Teacher {
String name;
int age;
//静态代码块：随着类的加载而加载，只加载一次，加载类时需要做的一些初始化，比如加载驱动
static {
System.out.println("我爱Java");
}
public Teacher() {
System.out.println("我是无参空构造");
}
public Teacher(String name,int age) {
System.out.println("我是有参构造");
this.name = name;
this.age = age;
}
}
3.4 每种代码块特点:
3.4.1 局部代码块:
以”{}”划定的代码区域，此时只需要关注作用域的不同即可
方法和类都是以代码块的方式划定边界的
3.4.2 构造代码块
优先于构造方法执行，构造代码块用于执行所有对象均需要的初始化动作
每创建一个对象均会执行一次构造代码块。
3.4.3 静态代码块
它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。
该类不管创建多少对象，静态代码块只执行一次。
可用于给静态变量赋值，用来给类进行初始化。
3.4.4 案例代码九:
package com.itheima_04;
/*
* Coder静态代码块执行 --- Coder构造代码块执行 --- Coder无参空构造执行
*
*
* BlockTest静态代码块执行 --- BlockTest的主函数执行了 --- Coder静态代码块执行 --- Coder构造代码块执行 --- Coder无参空构造执行
* Coder构造代码块执行 --- Coder无参空构造执行
*
*/
public class BlockTest {
static {
System.out.println("BlockTest静态代码块执行");
}
{
System.out.println("BlockTest构造代码块执行");
}
public BlockTest(){
System.out.println("BlockTest无参构造执行了");
}
public static void main(String[] args) {
System.out.println("BlockTest的主函数执行了");
Coder c = new Coder();
Coder c2 = new Coder();
}
}
class Coder {
static {
System.out.println("Coder静态代码块执行");
}
{
System.out.println("Coder构造代码块执行");
}
public Coder() {
System.out.println("Coder无参构造执行");
}
}
原文地址：https://www.cnblogs.com/bigorangehasc/p/8639240.html