JavaSE_day25(匿名对象，final关键字,abstract关键字、抽象类说明以及实例运用)

QuitXIN

已于 2023-04-21 18:24:19 修改

阅读量44

点赞数

文章标签： java eclipse 学习

于 2023-04-21 18:24:09 首次发布

本文链接：https://blog.csdn.net/weixin_52479647/article/details/130290253

版权

1、A_AnonymousObejctDemo 匿名对象

* 匿名对象:没有名字的对象
* 匿名对象的应用场景：
*        当方法只调用一次的时候可以使用匿名对象
*        可以当作参数进行传递，但是无法在传参之前做其他的事情（就是说每次new的都是新的对象，即使之前旧对象做了什么操作都是无用的！）
*
* 注意：匿名对象可以调用成员变量并赋值，但是赋值并没有意义,因为每次new一个出来都是不同的！
*

package day25_20221122;


/*
 * 匿名对象:没有名字的对象
 * 匿名对象的应用场景：
 * 		当方法只调用一次的时候可以使用匿名对象
 * 		可以当作参数进行传递，但是无法在传参之前做其他的事情（就是说每次new的都是新的对象，即使之前旧对象做了什么操作都是无用的！）
 * 	
 * 注意：匿名对象可以调用成员变量并赋值，但是赋值并没有意义,因为每次new一个出来都是不同的！
 * 			
 */
public class A_AnonymousObejctDemo {
	public static void main(String[] args) {
		Student s = new Student();
		s.study();
		s.study();
		s.study();
		System.out.println("-------------------");
		new Student();//匿名对象，没有变量引用的对象
		new Student().study();
		new Student().study();
		new Student().study();
		System.out.println("-------------------");
		new Student().age = 18;
		System.out.println(new Student().age);  //输出0，上面之前的赋值没有意义！
		
		System.out.println("-------------------");
		Student s1 = new Student();
		s1.age = 18;
		s1.name = "张三";
		method(s1);
		System.out.println("-------------------");
		method(new Student());
		
	}
	
	public static void method(Student s) {
		System.out.println(s.name+"好好学习，高薪就业");
	}

		
}


class Student {
	String name;
	int age;
	
	public void study() {
		System.out.println("好好学习，高薪就业");
	}
}

2、B_FinalDemo

* final：修饰符，可以用于修饰类、成员方法和成员变量
* final所修饰的类：不能被继承，(不能有子类)
* final所修饰的方法:不能被重写
* final所修饰的变量：是不可以修改的，是常量
*
* 常量：
* 字面值常量：1,2,3
* 自定义常量：被final所修饰的成员变量，一旦初始化则不可改变
*
* 注意：自定义常量必须初始化，可以选择显示初始化或者构造初始化
*

public class B_FinalDemo {
	public static void main(String[] args) {
		Animal a = new Animal();
		a.eat();
		
		Dog d = new Dog();
		d.eat();
		
//		d.num = 20;报错了 final不给重新赋值
		System.out.println(d.num);
	}
}

/*final*/ class Animal {
	public final void eat() {
		System.out.println("吃东西");
	}
}

class Dog extends Animal {
	/*public void eat() {}*/
	
	//自定义常量必须初始化，可以选择显示初始化或者构造初始化（俩种方式初始化，不然就会报错）
	final int num;
	
	public Dog() {
		num = 10;
	}
}

3、C_AbstractDemo
* abstract:关键字，用于修饰方法和类
* 抽象方法：不同类的方法是相似，但是具体内容又不太一样，所以我们只能“抽取他的声明”，“没有具体的方法体”，没有具体方法体的方法就是抽象方法
* 抽象类：有抽象方法的类必须是抽象类
*
* 注意：一个类继承了抽象类需要“重写他所有的抽象方法”,“否则”这个类就得是抽象类
*/

public class C_AbstractDemo {

	
	
	
}

abstract class Animal1 {
	//抽象类的抽象方法，必须重写！ 
	public abstract void eat();
	
	//非抽象方法子类可以不重写
	public void run() {
		
	}
}

class Cat1 extends Animal1 {

	@Override
	public void eat() {
		System.out.println("猫吃鱼");
		
	}
	
	/*public void eat() {
		System.out.println("猫吃鱼");
	}*/
}

abstract class Dog1 extends Animal1 {
//	！！我是抽象类，虽然我继承了，但是我就是可以不重写抽象方法
	
	/*public void eat() {
		System.out.println("狗吃屎");
	}*/
}

4、D_AbstractDemo2

* 抽象类的特点：
*        "抽象方法只能在抽象类里面"
*        抽象类和抽象方法必须被abstract修饰
*        "抽象类不能创建对象（不能实例化）"，但是可以有构造方法（见下文）
*        "抽象类中可以有非抽象的方法"
*        抽象类和类的关系也可以是继承关系
*        一个类继承了抽象类要么重写所有的抽象方法，要么他自己是抽象类

public class D_AbstractDemo2 {
	public static void main(String[] args) {
		//Animal2 a = new Animal2();报错了 ，抽象类无法实例化！ 
	}
}

 abstract class Animal2 {
	public abstract void eat();
	
	public void run() {
		
	}
}

class Cat2 extends Animal2 {

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		
	}

}

5、E_AbstractDemo3

* 抽象类的成员特点：
*        成员变量
*            可以有成员变量
*            可以有常量
*        成员方法
*            可以有抽象方法
*            可以有非抽象方法
*        构造方法
*            可以有构造方法的，可以在构造方法内对抽象类的成员变量进行初始化
*
* final:修饰类、成员变量、成员方法

public class E_AbstractDemo3 {
	public static void main(String[] args) {
		Dog3 d = new Dog3();//默认会调用父类的构造方法
//		d.name="666";
		d.barking();
	}
}

abstract class Animal3 {
	String name = "哮天犬";
	final int num ;
	
	public Animal3() {
		System.out.println("我是抽象类的构造方法(父类)");
		num=100;
	}
	
	public abstract void eat();
	
	public void run() {}
}

class Dog3 extends Animal3 {
	
	public void barking() {
		System.out.println(name);
		System.out.println(num);
	}

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		
	}
}

6、抽象类实例运用1：

package day25_20221122;

public abstract class F_Teacher {
	private String name;//姓名
	private int age;//年龄
	private String gender;//性别
	
	public F_Teacher() {
		super();
		// TODO Auto-generated constructor stub
	}
	public F_Teacher(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;
	}
	
	//讲课,由于具体讲课内容不一样，所以声明出方法，不写方法体内容
	public abstract void teach();
	
	
}

package day25_20221122;

public class F_JobTeacher extends F_Teacher{

	@Override
	public void teach() {
		System.out.println(getName()+","+getAge()+","+getGender()+"：讲JavaEE课程");
	}

}

package day25_20221122;

public class F_BasicTeacher extends F_Teacher {

	@Override
	public void teach() {
		System.out.println(getName()+","+getAge()+","+getGender()+ "：讲JavaSE课程");
	}

}

package day25_20221122;

/*
 * 测试类，测试抽象类与他的子类们是否能成功运行！
 * 
 * 
 *	基础班老湿，就业班老湿

 *	共性
 *		属性	姓名，年龄，性别
 *		行为	讲课
 */
public class F_AbstractTest {
	public static void main(String[] args) {
		//创建基础班老湿对象
		F_BasicTeacher bt = new F_BasicTeacher();
		//为基础班老湿对象的成员变量进行赋值
		bt.setName("风清扬");
		bt.setAge(100);
		bt.setGender("男");
		bt.teach();
		
		//创建就业班老湿对象
		F_JobTeacher jt = new F_JobTeacher();
		//为就业班老湿对象的成员变量进行赋值
		jt.setName("东方");
		jt.setAge(18);
		jt.setGender("女");
		jt.teach();
	}
}

7、抽象类实例运用2

package day25_20221122;

public abstract class G_Employee{
	private String name;//姓名
	private String id;//工号
	private double pay;//薪水
	
	public G_Employee() {
		super();
		// TODO Auto-generated constructor stub
	}
	public G_Employee(String name, String id, double pay) {
		super();
		this.name = name;
		this.id = id;
		this.pay = pay;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public double getPay() {
		return pay;
	}
	public void setPay(double pay) {
		this.pay = pay;
	}
	//抽象方法，只声明名字！
	public abstract void work();
}

package day25_20221122;

public class G_Manager extends G_Employee{
	private byte bonus;//属于自己的属性，父类中并没有

	public byte getBonus() {
		return bonus;
	}

	public void setBonus(byte bonus) {
		this.bonus = bonus;
	}

	@Override
	public void work() {
		System.out.println("id:"+getId()+",名字：" +getName()+",工资："+getPay()+",奖金:"+getBonus()+",正在跑业务...");
	}
}

package day25_20221122;

public class G_Programmer  extends G_Employee {

		@Override
		public void work() {
			System.out.println("id:"+getId()+",名字：" +getName()+",工资："+getPay()+":正在写代码...");
		}

	}

package day25_20221122;

/*
 *	员工(Employee)示例：
	需求：
		公司中 
			程序员(Programmer)有姓名(name)，工号(id)，薪水(pay)，工作(work)。
			项目经理(Manager)除了有姓名(name)，工号(id)，薪水(pay)，工作(work)，还有奖金(bonus)。
	
	
	共性
		属性	姓名，工号，薪水
		行为	工作


	
 */
public class G_AbstractTest2 {
	public static void main(String[] args) {
		//创建程序员对象
		G_Programmer p = new G_Programmer();
		p.setName("张三");
		p.setId("002");
		p.setPay(10000);
		p.work();
		
		//创建项目经理的对象
		G_Manager m = new G_Manager();
		m.setName("比尔盖茨");
		m.setId("001");
		m.setPay(0);
		m.setBonus((byte)100);
		m.work();
	}
}

8、抽象类补充说明

public class H {
/*
	 A:抽象类关键字abstract不可以和哪些关键字共存?
		 1.private：[ 只允许在本类中使用！]
		 	私有的方法子类是无法继承到的，也不存在覆盖，而abstract和private一起使用修饰方法，abstract既要子类去实现这个方法，而private修饰子类根本无法得到父类这个方法。互相矛盾。
		 2.final:  [ final所修饰的类：不能被继承，(不能有子类),final所修饰的方法:不能被重写 ]
		   	抽象类不能和final共存,因为抽象类自身无法创建对象,我们需要通过子类创建对象,一旦抽象类使用final关键字,那么抽象类就没有子类
		   	抽象方法不能和final共存,因为抽象方法后期需要被子类重写,一旦加final无法重写   
		 3.static:  [ static::静态关键字，他是一个关键字，用来修饰成员变量和成员方法]
		  	抽象方法不能和static关键字共存,因为一旦加static我们就可以通过类名直接访问抽象方法[思考：如果可以共存的话，抽象类不能实例化的意义何在？],由于抽象方法没有方法体,没有任何意义,也不允许这样做
	 B:抽象类中是否可以不定义抽象方法?
			是可以的，那这个抽象类的存在到底有什么意义呢？不让该类创建对象,方法可以直接让子类去使用
	 C:抽象类是否有构造函数?
		        有,抽象类的构造函数,是由子类的super语句来调用,用于给抽象类中的成员初始化

*/
	
	
}