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

匿名类的引入

在某些场景下，类的名称并不重要；我们只想使用类中的方法；
这个时候我们可以采用特殊语法；匿名类

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";
	}
}

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

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);
	}
}