7.方法、常量、内部类和枚举

方法

1.定义

把代码逻辑细节用方法封装起来，通过对象能够重复调用方法，代码复用，提高工作效率。

//行为:叫做方法。
	public void study() {
		System.out.println("学习");
	}

2. 方法种类

1. 无返回值的无参方法

   //void代表无返回值
   //()中写写形参,空代表没有参数
   public void game() {
   		System.out.println("游戏");
   	}
   

2. 无返回值的有参方法

   //方法中有参赛,为形参
   public void study(String name,int time) {
   		System.out.println(name+"一天学习" + time +"小时");
   	}
   //调用方法时传递的为实参
   study("小明",10);
   
   结果:
   小明一天学习10小时;
   

3. 有返回值的无参方法

   //int代表返回值为int类型,
   public int add() {
   		teturn 1;
   	}
   

4. 有返回值的有参方法

   public int add(int a,int b) {
   		return a+b;
   	}
   System.out.println(add(5,6));
   
   结果:
   11
   

方法重载

在同一个类中,多个方法名相同,但参数的顺序、类型、个数不同,与返回值无关,叫做方法重载。

1. 构造方法重载

   public class Student {
   	private String  name;
   	private int age;
   	private char sex;
   	private double money;
   		
   	//构造方法重载
   	public Student() {
   		super();
   	}	
   	
   	public Student(String name) {
   		super();
   		this.name = name;
   	}
   
   	public Student(String name, int age) {
   		super();
   		this.name = name;
   		this.age = age;
   	}
   
   	public Student(String name, int age, char sex) {
   		super();
   		this.name = name;
   		this.age = age;
   		this.sex = sex;
   	}
       
   	public Student(String name, int age, char sex, double money) {
   		super();
   		this.name = name;
   		this.age = age;
   		this.sex = sex;
   		this.money = money;
   	}	
   }
   

   static

   静态的,static可以用来修饰:

   1. 静态变量(类变量):可以直接通过类名.变量名调用

      static double money=100;//类变量,通过类调用
      

   2. 静态方法(类方法):可以直接通过类名.方法名调用

      public static void show2() {
      		//静态方法中不能够直接调用非静态变量好方法,如果要调用要先创建对象再去调用
      		System.out.println("用static修饰的方法叫做类方法,通过类调用");
      	}
      

   3. 静态代码块:当java虚拟机(jvm)加载类的时候,就会执行该代码块

      //静态代码块加载类的时候就执行,先执行静态代码块再加载Student()构造方法
      	static {
      		studentNo = 1001;
      	}
      

      • 静态变量是通过类名直接调用(也可以通过对象名调用)
      • 静态方法中不能够直接调用非静态变量好方法,如果要调用要先创建对象再去调用
      • 成员方法能直接调用静态变量和静态方法

final

• final修饰的变量叫常亮,值是不可以被修改的,并且需要赋初始值。

• final修饰的方法不能重写

• final修饰的类不能被继承

• 局部常量可以不赋初始值

  	String name;//变量 值可以改变
  	final int DAY = 7;//
  	
  	public void show() {
  		final String company;
  		company = "zx";//局部常量可以不赋初始值
  		System.out.println("公司名称:" + company);
  		//调用静态常量
  		System.out.println("今天是:" + ConstantUtil.WEEK2);
  	}
  	
  	public static void main(String[] args) {
  		Student stu = new Student();
  		stu.show();
  	}
  

  /**
   * 
   * 	在实际项目中,一般会把项目中用到的常量全部放在一个工具类中
   *
   */
  public class ConstantUtil {
  	//静态常量
  	public static final String WEEK1="星期一";
  	public static final String WEEK2="星期二";
  	public static final String WEEK3="星期三";
  	public static final String WEEK4="星期四";
  	public static final String WEEK5="星期五";
  	public static final String WEEK6="星期六";
  	public static final String WEEK7="星期日";
  }
  

内部类

• 为什么需要使用内部类？

1. 为什么需要内部类？

   • 解决了多继承的问题，继承具体或抽象类。

   • 一般来说，内部类继承自某个类或实现某个接口，内部类的代码操作创建它的外围类的对象。所以可以认为

   • 内部类提供了某种进入其外围类的窗口。

   • 内部类最吸引人的原因是：每个内部类都能独立地

   • 继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。

• 如果没有内部类提供的、可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。从这个 角度看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效的实现了“多重继承”。也就是说，内部类允许继承多个非接口类型。

• 考虑这样一种情形：如果必须在一个类中以某种方式实现两个接口。由于接口的灵活性，你有两种选择：使 用单一类或者使用内部类。但如果拥有的是抽象的类或具体的类，而不是接口，那就只能使用内部类才能实现多重继承。

2. 使用内部类，还可以获得其他一些特性：

   • 内部类可以有多个实例，每个实例都有自己的状态信息，并且与其外围类对象的信息相互独立。

   • 在单个外围类中，可以让多个内部类以不同的方式实现同一个接口或继承同一个类。

   • 创建内部类对象的时刻并不依赖于外围类对象的创建。

   • 内部类并没有令人迷惑的is-a关系，它就是一个独立的实体

3. 内部类分为成员内部类、静态内部类、方法内部类、匿名内部类。

• 成员内部类

  /**
   * 	成员内部类
   * @author Administrator
   *
   */
  public class Outer {
  	private int a = 0;
  	public void OuterTest() {
  		System.out.println("这是一个外部类方法");
  		//内部类的方法提供给外部类使用,需要创建对象调用
  		//也可以使用静态内部类,通过内部类.方法名调用更简单
  		Inner in = new Inner();
  		in.innerTest();
  	}
  	
  	public class Inner{
  		int b = 2;
  		public void innerTest() {
  			System.out.println("这是一个内部类方法");
  			System.out.println("访问外部类的a:"+a);
  			System.out.println("访问内部类的b:"+b);
  		}
  	}
  	public static void main(String[] args) {
  		//内部类是作为外部类的一个成员,内部类是该外部类服务的,其他类不允许操作
  		//如果非要操作,就应该先创建外部类对象再去调用内部类对象
  		Outer outer = new Outer();
  		Inner in = outer.new Inner();
  		in.innerTest();
  	}
  }
  

  public class Outer {
  	String name = "张三";
  	
  	//内部类作为外部类的成员
  	Inner in = new Inner();  
  	
  	public class Inner{
  		String name = "李四";
  		public void innerTest() {
  			System.out.println("访问内部类的name:" + this.name);
  			System.out.println("访问`外部类的name:" + Outer.this.name);
  		}
  	}
  	public static void main(String[] args) {
  		Outer out = new Outer();
  		Inner in1 = out.new Inner();
  		in1.innerTest();
  		//调用方式二
  		out.in.innerTest();	
  	}
  }
  

  1.如果外部类的name变量和内部类的重名，优先使用内部类的name,

  2.如果需要访问外部类的name属性，需要类名.this.name来访问。

• 静态内部类

  public class Outer {
  	String name="张三";
  	static String hibby="篮球";
  	public static class Inner{
  		String name2 = "李四";
  		public static void test() {
  			Inner in = new Inner();
  			System.out.println("访问内部类的name2:"+in.name2);
  			Outer outer = new Outer();
  			System.out.println("外部类的name" + outer.name);
  			System.out.println("外部类的静态变量:" + Outer.hibby);
  		}
  	}
  }
  

  public class Test {
  	public static void main(String[] args) {
  		//静态内部类不需要创建外部类对象,可以直接创建静态内部类的对象调用
  		Inner in = new Inner();
  		in.test();
  		
  		Inner.test();
  	}
  }
  

  1.注意：静态内部类不需要创建外部类对象，可以直接创建静态内部类对象调用

  2.静态内部类如果需要访问外部类的非静态成员，需要创建对象访问

  3.静态内部类访问外部类静态成员，需要通过类名.属性来访问

• 方法内部类

  1.方法外部类就是定义在外部类的方法中，方法内部类只在该方法内可以使用

  2.由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和

  static修饰符

  /**
   * 	方法内部类
   * @author Administrator
   *
   */
  public class Outer {
  	public void show() {
  		final int a = 5;
  		int b = 15;
  		class Inner{
  			int c = 12;
  			//方法内部定义的内部类,叫方法内部类,给show方法内提供支持
  			public void  print() {
  				System.out.println("访问外部类的方法中的处常量:"+a);
  				System.out.println("访问外部类的方法中的变量:"+b);
  				System.out.println("访问内部类中的变量:"+c);
  			}
  		}
  		Inner in = new Inner();
  		in.print();
  	}
  	public static void main(String[] args) {
  		Outer out = new Outer();
  		out.show();
  	}
  }
  

• 匿名内部类

  匿名内部类也就是没有名字的内部类

  正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写

  但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口

  public interface Person {
  	void eat();
  
  }
  

  public class Test {
  	public static void main(String[] args) {
  		Person per = new Person() {
  			
  			@Override
  			public void eat() {
  				// TODO Auto-generated method stub
  				System.out.println("这是匿名内部类,是person的没有具名的子类,必须重写接口的方法");
  			}
  		};
  		per.eat();
  	}
  }
  

  public class Test {
  	public static void main(String[] args) {
  		Person per =()->{
  				System.out.println("这是匿名内部类,是person的没有具名的子类,必须重写接口的方法");
  		};
  		per.eat();
  	}
  }
  

枚举

枚举是jdk1.5之后的新特性,是一种数据类型,可以将常量组织起来,使代码更加易读、安全、统一管理。

(1)类中的枚举

public class Student {
	enum Week{
		星期一,
		星期二,
		星期三,
		星期四,
		星期五,
		星期六,
		星期日
	}
	
	public void show() {
		//week的数据类型是Week枚举类型,就约定了week变量里面的值只能是week枚举里面这七个固定的常量
		//数据类型就比常量更为严格
		Week week = Week.星期一;
		System.out.println("今天是" + week);
	}
	
	public static void main(String[] args) {
		new Student().show();
	}

}

(2)枚举类

public enum Color {
	RED,YELLOW,GREEN
}

public class Test {
	public static void main(String[] args) {
		Color color = Color.RED;
		switch (color) {
		case RED:
			System.out.println("红灯停");
			break;
		case YELLOW:
			System.out.println("黄灯等一等");
			break;
		case GREEN:
			System.out.println("绿灯行");
			break;
		default:
			break;
		}
	}
}

(3)以枚举类型作为方法的参数

public class InfoTest {
	
	//以枚举类型作为方法的参数
	public static String getColor(Color color) {
		String instruct ="信号灯故障";
		switch (color) {
		case RED:
			instruct ="红灯停";
			break;
		case YELLOW:
			instruct ="黄灯等一等";
			break;
		case GREEN:
			instruct ="绿灯行";
			break;
		default:
			break;
		}
		return instruct;
	}
}

public class Test {
	public static void main(String[] args) {
		String info = InfoTest.getColor(Color.YELLOW);
		System.out.println("信号灯信息:" + info);
	}
}