09 Javabean以及继承

09

Javabean

• 是一个普通类, 用来描述一些对象. 例如: Teacher, Student , Mobile , Rect

规范:

• 成员变量私有化
• 提供setters/getters
• 提供无参的构造方法
• 提供有参的构造方法
  • 自动生成set()/get()方法: 右键–>source–>generate getters and setters–>选择属性(select All)–>ok
  • 自动生成构造方法: 右键–>source–>generate constructor using fileds–>选择属性–>ok

public class User {
	private String username;
	private String password;
	private String phone;
	private int age;
	private String sex;
	
	public User() {
		super();
	}

	public User(String username, String password, String phone, int age, String sex) {
		super();
		this.username = username;
		this.password = password;
		this.phone = phone;
		this.age = age;
		this.sex = sex;
	}
	
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public String getPhone() {
		return phone;
	}
	public void setPhone(String phone) {
		this.phone = phone;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}

	@Override
	public String toString() {
		return "User [用户名=" + username + ", 密码=" + password + ", 电话=" + phone + ", 年龄=" + age + ", 性别="
				+ sex + "]";
	}	
}

同名局部变量和成员变量的区分

• 使用this关键词进行区分

• this代表本类中的成员变量

• 若没有this关键词修饰则, 则表现就近原则

• 谁调用了含有this的方法 , 那么this就代表谁

成员变量:

• • 定义在类中方法外, 不被static修饰的变量叫做成员变量
  • 一般位于堆内存中, 有初始化值
  • 随着对象的创建而创建, 随着对象的消失而消失

局部变量:

• • 定义在方法中
  • 一般位于栈内存中
  • 随着方法的运行而加载, 随着方法运行完毕而结束

public class Person {
	String name = "张三";

	public void print() {// 1
		System.out.println(name);
	}

	public void print(String name) {// 2
		System.out.println(name);
	}

	public void print1(String name) {// 3
		System.out.println(this.name);
	}

	public static void main(String[] args) {
		Person p = new Person();
		System.out.println(p.name);//张三

		p.name = "李四";
		p.print();//李四

		p.print("王五");//王五

		p.print1("赵六");//赵六
	}
}

static关键字

• 类中的非静态成员, 使用对象调用
• 类中的静态方法和静态变量, 是类名调用
• 类中的构造方法是使用new关键字创建对象时调用

简述static关键字:

1. static, 用于修饰变量和方法, 被其修饰的变量和方法变为静态变量和静态方法
2. 随着类的加载而加载 ( 先于对象的存在 ) , 被所有的对象所共享 ( 只有一份 ) , 可以使用类名调用
3. 静态方法中只能调用外部使用static修饰的方法和变量 , 如果要调用非静态的则必须创建对象

代码块

• 静态代码块: 随着类的加载而加载
  • 只运行一次 , 只要.class文件在内存区 , 那么static代码块就永远不会再执行

class Demo1{
    static{
        
    }
}

• 构造代码块: 随着对象的创建而运行

class Demo2{
    {
        
    }
}

• 局部代码块: 处于方法中, 随着方法的运行而加载
  • 如果一个方法中有大量只使用一次就不再使用的代码 , 可以使用局部代码块进行封装 , 封装完毕后, 一旦局部代码块执行完毕 , 那么这些变量或者其他就会被立即释放

class Demo3{
    main{
        {
            
        }
    }
}

public class ExtendDemo1 {

	static {
		System.out.println("我是静态代码块");
	}

	{
		System.out.println("我是构造代码块");
	}

	public static void main(String[] args) {
		ExtendDemo1 d1 = new ExtendDemo1();
		ExtendDemo1 d2 = new ExtendDemo1();
		ExtendDemo1 d3 = new ExtendDemo1();
		ExtendDemo1 d4 = new ExtendDemo1();
		
		{
			System.out.println("我是局部代码块");
		}
		
	}
}

继承

• 同一个包中不能定义名字相同的类
• 一个文件中可以定义多个类
• 只有一个类可以使用public来修饰 , 用public修饰的类必须和文件名保持一致 , main方法必须定义在此类中

格式:

class 子类 extends 父类{
    
}

• 继承的类 : 子类或派生类
• 被继承的类 : 父类或基类或超类

public class ExtendDemo1 {
	public static void main(String[] args) {
		Dog d = new Dog();
		d.age = 1;
		d.sex = "公";
		d.name = "山河";
		d.shout();
		d.eat();
	}
}

class Animal {
	int age;
	String sex;

	public void shout() {
		System.out.println("叫");
	}
}

class Dog extends Animal {
	String name;

	public void eat() {
		System.out.println(name + "吃骨头" + "今年" + age + "岁了" + sex );
	}
}

class Cat extends Animal {
	String name;

	public void sleep() {
		System.out.println("白天睡觉,晚上蹦迪");
	}
}

class Monkey extends Animal{
	String name;
}

注意事项:

• Java语言中的只支持单继承 , 不支持多继承 , 但是支持多层继承
• 父类中的私有成员 , 构造方法是不能被继承的
• 如果一个类没有继承任何类 , 那么其默认继承自Object . 一般讲Object类称为万类之祖

super关键字

• 静态方法中不可以使用this/super关键字
• this/super不可以同时在同一构造方法中同时做调用构造方法使用 , 因为this/super关键字都必须放在构造方法第一行使用
• super : 指代父类中的对象
  • 用于子类的成员和父类的成员变量重名时 , super指代父类中的成员变量
• this : 指代子类中的对象
  • 用于成员变量和局部变量重名时 , this指代成员变量

1. 调用成员:

2. this.成员(成员变量/成员方法);
       
   super.成员(成员变量/成员方法)
   

   调用构造方法

this.(参数);              //调用本类中的构造方法

super.(参数);             //调用父类中的构造方法

继承中构造方法的关系

• 默认情况下 , 每个构造方法的第一行都省略了super()
• super()主要负责调用父类的无参构造
• 子类的构造方法想要运行或者子类的对象想要创建成功 , 必须得运行一下父类的构造方法 , 只不过默认情况下 , 运行的是父类的无参构造

public class ExtendDemo2 {
	public static void main(String[] args) {
		XiaoShuo xs = new XiaoShuo();
		
		xs.look();
	}
}

class Book{
	String name;
	String author;
	
	public Book(String name,String author){
		System.out.println("我是父类的构造方法");
	}
	
	public void look() {
		System.out.println("看书");
	}
}
class XiaoShuo extends Book{
	String price;
	
	public XiaoShuo() {
		this(null);
		System.out.println("我是子类的构造方法");
	}
	
	public XiaoShuo(String price) {
		super(null, null);
		System.out.println("我是子类的有参构造");
		this.price = price;
	}
	
	public void look() {
		super.look();
		System.out.println("看小说容易让人上瘾");
	}
}

继承中成员的关系

• 现在子类中找 , 若子类没有去父类中找 , 若子类父类都没有则报错

方法的重载与重写

方法的重载 ( overload ) : 一个类中可以存在多个名字相同的方法 , 但必须保证参数的个数或类型不同 , 与返回值无关

方法的重写 ( override ) : 子类中出现了和父类中方法名 , 参数列表 , 返回值类型都相同的成员方法 , 也叫做方法的覆写

public class ExtendDemo3 {
	public static void main(String[] args) {
		Manager manager = new Manager();
		manager.eat();
		manager.work();
		manager.manage();
	}
}
class Worker{
	String name;
	String id;
	String sex;
	int salary;
	public void work() {
		System.out.println("员工搬砖");
	}
	public void eat() {
		System.out.println("员工吃零食");
	}
}
class Manager extends Worker{
	int bonus;
	public void manage() {
		System.out.println("管理团队");
	}
	@Override
	public void work() {
		System.out.println("经理监工");
	}
}

final关键字

• 修饰符 , 可以用来修饰类 , 方法 , 变量

• 被final修饰的类不可以被继承

• 被final修饰的方法不能被重写

• 被final修饰的变量值不能改变

  • final修饰的变量一定要有初始值
  • final修饰的引用数据类型 , 地址值不可以改变 , 可以改变里面的属性值

• 一般在定义时 , final关键字和static关键字一起使用

单例设计模式

目的 :

让类只能产生一个实例 ( 对象 )

思路 :

1. 私有化无参构造
2. 对外提供一个返回本类对象的方法
3. 在成员位置创建一个私有的静态的被final修饰的本类对象
4. 在公共方法中将该对象return

饿汉式 :

//饿汉式
public class Singleton {
	
	private static final Singleton s = new Singleton();//不具备懒加载
	
	private Singleton() {
		
	}
	
	public static Singleton getInstance() {
		return s;
	}
}

//懒汉式--存在线程安全的问题
public class Singleton2 {

	private static Singleton2 s2;

	private Singleton2() {

	}

	public static Singleton2 getInstance() {
		if (s2 == null) {
			s2 = new Singleton2();
		}
		return s2;
	}
}