java中匿名类，Bean规范，全局变量

实现看见一个人，我们对它说hello

public class study01 {
	public static void main(String[] args) {
		Me me = new Me();
		me.SayHello(new ZhangSan());
		
	}
	
}
// 定义了一个抽象类；
abstract class Person {
	public abstract String name();
}

class Me{
	public void SayHello(Person Person){
		System.out.println("你好" + Person.name());
	}
}

class ZhangSan extends Person{
	public String name(){
			return "shangsan";
	}
}

ps：上面这个代码主要是想说：类的名称并不重要；
我们只是想使用类中的方法；
如果这里我们还想给：王五，王六说你好；
是不是还要添加一个王五类，王六类；
这样太麻烦了。我们可以使用匿名类

匿名类的引入

在某些场景下，类的名称并不重要；我们只想使用类中的方法；  
这个时候我们可以采用特殊语法；匿名类  
匿名类是一种没有名字的内部类  
匿名类可以直接嵌入到代码中，通常出现在需要直接创建对象并使用其行为的地方。  
例如事件监听器、回调、或者某个接口的具体实现。
匿名类的语法形式如下：
new NiNameClass() {
    // 方法实现或者具体的逻辑
};

public class study01 {
	public static void main(String[] args) {
		Me me = new Me();
    //	这样我们就不需要再去写一个王六类，王七类了	
		me.SayHello(new Person(){
			public String name(){
				return "wamgliu";
			}
		});
	}	
}
// 定义了一个抽象类；
abstract class Person {
	public abstract String name();
}

class Me{
	public void SayHello(Person Person){
		System.out.println("你好" + Person.name());
	}
}

class ZhangSan extends Person{
	public String name(){
			return "shangsan";
	}	
}

匿名类的应用场景

1.实现接口:实现简单接口而不必创建单独的类。  
2.继承类:临时重写父类的某个方法，适合做简单扩展。  
3.处理事件: 在 GUI 编程中，匿名类经常用于事件监听器的实现。  
4.线程执行:用于 Runnable 接口的快速实现，简化代码。  

匿名类的局限性

虽然匿名类能够简化代码的编写，但在某些情况下它也有一定的局限性：
1,只能使用一次：匿名类是一次性使用的类，不能在其他地方重复使用。如果需要复用代码，还是需要定义一个具名类。
2,不能定义构造函数：匿名类无法定义自己的构造函数，但可以调用父类的构造函数。
3,代码可读性差：当匿名类逻辑复杂时，可读性可能较差，尤其是当类体过长、代码嵌套较深时，维护起来较为困难。
4.局部变量的限制：匿名类只能访问外部类的有效最终变量（即外部方法的局部变量在匿名类中未被修改）这也是Java的作用域限制之一。

接口可以通过类来实现，毕竟接口也是一种规范；

public class study01 {
	public static void main(String[] args) {
        // new Brid().fly();
		
		new Fly(){
			  public void fly(){
				  System.out.println("使用飞行器飞行");
			  }
		}.fly();
		
	}
}

//  声明的是抽象接口
interface Fly {
	// 这是一个抽象方法；因为接口中的方法是抽象方法
	// 同时接口中定义的属性都是常量
	public void fly();
}

class Brid implements Fly{
	public void fly(){
		System.out.println("开始飞行");
	}
}

Bean的规范

Bean的规范要求：
1.类的要求必须是无参，公共的构造方法;
2.属性必须私有化，然后提供公共的get,set方法

Bean规范实现登录逻辑

ublic class study01 {
	public static void main(String[] args) {
       User user1 = new User();
       // 给属性设置值
       user1.setAccount("admin");
       user1.setPassword("123");
       // 调用登录方法
       System.out.println(login(user1));
	}
	
	// 登录方法
	public static Boolean login(User user){
		if(user.getAccount()== "admin" && user.getPassword()=="123"){
			return true;
		}else {
			return false;
		}
	}
}

// Bean规范
class User {
	private String  account;
	private String password;
	
	// 提供账号
	public String getAccount(){
		return account;
	}
	// 提供密码
	public String getPassword(){
		return password;
	}
	
    //	设置密码，因为没有返回值，所以我写上void
	public void setPassword(String password){
		this.password = password;
	}
	// 设置用户名;; 因为没有返回值，所以我写上void
	public void setAccount(String  account){
		this.account = account;
	}
}

如果属性和局部变量名称相同，如果访问是不加任何修饰符，优先访问局部变量；

public class study01 {
	public static void main(String[] args) {
       User u =new User();
       u.test();  // 输出的是-lisi
	}
}
class Person26 {}
class  User extends Person26{
	// 这是一个属性
	public String name="wangwu";
	public void test(){
		// 这是一个局部变量
		String name ="lisi";
		System.out.println("名称:"+ name);
	}
}

如果没有局部变量，访问的是属性

public class study01 {
	public static void main(String[] args) {
      User u =new User();
      u.test();  // 输出的是-wangwu
	}
}

class Person26 {}

class  User extends Person26{
	// 这是一个属性
	public String name="wangwu";
	public void test(){
		// 如果没有局部变量，访问的是属性
		// String name ="lisi";
		System.out.println("名称:"+ name);
	}
}

父类和子类有相同属性，优先访问子类属性，如果子类没有，然后访问父类属性

ublic class study01 {
	public static void main(String[] args) {
    User u = new User();
    u.test();  // 输出的是-wangwu
	}
}

class Person26 {
	public String name="zhangsan";
}

class  User extends Person26{
	// 这是一个属性
	public String name="wangwu";
	public void test(){
		System.out.println("名称:"+ name);
	}
}