第五章高级类的特性2

最新推荐文章于 2024-03-29 19:19:34 发布

X.. R H

最新推荐文章于 2024-03-29 19:19:34 发布

阅读量186

点赞数

分类专栏： JavaSE

本文链接：https://blog.csdn.net/weixin_47160763/article/details/107070192

版权

JavaSE 专栏收录该内容

22 篇文章 1 订阅

订阅专栏

关键字static

static String country;// 类变量不用实例化，直接类名.属性名使用，是类的一部分，被所有类的实例化对象所共享，也可以叫静态变量
int age;//实例变量，只有实例化后才能使用，属于实例化对象的一部分，不能共用
在这里插入图片描述
如果方法与调用者无关，则这样的方法通常被声明为类方法，由于不需要创建对象就可以调用类方法，从而简化了方法的调用

public class Utils {
//判断是否为空字符串
	public static boolean isEmpty(String s) {
		boolean flag=false;
		
		if(s!=null && !s.equals("") ) {
			flag=true;
			
			//多次使用，所以抽取到工作类
		};
		return flag;
	}
}

public static void main(String[] args) {
	String s ="11";
	
	System.out.println(Utils.isEmpty(s));
}

单例设计模式

单例(Singleton)设计模式-饿汉式

/** 
 * 单例模式-饿汉式
 * @author xrh
 *
 */
public class Single {

	//私有的构造,调用这个类的人不能随便new对象
	private Single() {
		
	}
	//私有的Single类型的类变量
	private static Single sin =new Single();
	
	public static Single getInstance() {
		return sin;
	}
	
}

懒汉式

/** 
 * 单例模式-懒汉式  最开始对象是null直到第一个调用，才new一个对象，之后所有的都用这个对象
 * @author xrh
 *
 */
public class Single {

	//私有的构造,调用这个类的人不能随便new对象
	private Single() {
		
	}
	//私有的Single类型的类变量
	private static Single sin =null;
	
	public static Single getInstance() {
		if (sin == null) {
			sin=new Single();
			
		}
		return sin;
	}
	
}

public static void main(String[] args) {
	
	Single s =Single.getInstance();
	Single s1 =Single.getInstance();
	Single s2 =Single.getInstance();
}

单例模式，软件的运行有且只有一个实例化对象（只会new一次）
懒汉式与饿汉式的区别是什么时候去New

懒汉式是在第一次调用getInstance方法是来new对象，以后再有人调用getIntance方法直接返回第一次New好的对象

饿汉式，是在类加载之后，还没有调用就先new好一个对象，以后不论谁来调用getInstance方法，都是直接返回之前new好的对象

理解main方法

public static void main(String[] args){}
由于java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public，又因为java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static的，该方法接收一个String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数。

类的成员之四：初始化块（代码块）

对Java对象进行初始化

public class Person {
	String name;
	public Person() {
		this.name="张三";
		System.out.println("执行的是构造方法");
		
	}
	//非静态的代码块
	{
		System.out.println("执行的是非静态代码块");
	}
}

public class Test {
	public static void main(String[] args) {
		new Person();
	}
}   //输出：执行的是非静态代码块
   //       执行的是构造方法

先执行的是代码块，后执行构造方法
静态代码块（只执行一次，非静态New一次对象运行一次）

public class Person {
	String name;
	static int a;
	public Person() {
		this.name="张三";
		System.out.println("执行的是构造方法");
		
	}
	//非静态的代码块
	{
		System.out.println("执行的是非静态代码块");
	}
	//静态代码块
	static{
		a=1;//这里只能使用静态static修饰的属性和方法
		showA();
		
	}
	public static void showA() {
		System.out.println(a);
	}
}

静态代码块的执行顺序先于非静态执行顺序
一般编程中，使用更多的是静态代码块，初始化类的静态属性（static属性），以及下面这种情况

public class Person {
	String name;
	static int a;
	public Person() {
		this.name="张三";
		System.out.println("执行的是构造方法");
		
	}
	//非静态的代码块
	{
		System.out.println("执行的是非静态代码块");
	}
	//静态代码块
	static{
		a=1;//这里只能使用静态static修饰的属性和方法
		showA();
		
	}
	public static void showA() {
		System.out.println(a);
	}
	
	public void test() {
		System.out.println("person的test方法");
	}
}

public class Test {
	public static void main(String[] args) {
		//匿名内部类
		Person p =new Person() {//一个Person的匿名子类
			
			//现在想把name改成李四，但不想动Person的代码
			{  //用代码块代替构造器
				super.name="李四";
			}
			@Override
			public void test() {
				System.out.println("===");//这里可以重写test方法，构建了一个没有类名的Person的子类
			}							  //也就是匿名的Person子类，这种没有类名，不能用new创建对象
										  //如果还要在构造器中初始化属性就没有办法了，就要用代码块初始化
		};
		System.out.println(p.name);
		p.test();
	}
}

类的成员之五：内部类

public class Test {
	int i;
	public int j;
	private int k ;
	
	class A{
		int i;
		
		public void set1() {
			Test.this.i=1;
			Test.this.j=2;
			Test.this.k=3;
			
		}
		
		public void sset() {
			this.i=5;
			
		}
		
	}
	
	public void setInfo() {
		new A().set1();  //外部类要用自己内部类的方法，必须先new内部类的对象
	}
	
	public void showInfo() {
		System.out.println(this.i);
		System.out.println(this.j);
		System.out.println(this.k);
	}
	public static void main(String[] args) {
		Test t=new Test();
		t.setInfo();
		t.showInfo();
	}
}

内部类主要解决java不能多重继承的问题

public class Test1 {
		public static void main(String[] args) {
			A a=new A();
			a.testB();
			a.testC();
		}
}
/**
 * 现在类A想同时获得类B和C的方法，并重写
 * 可以使用内部类变相的实现类的多重继承，可以同时继承多个类
 * @author xrh
 *
 */

	class A{           //java不支持class A extends B,C这样写
		
		public void testB() {
			new InnerB().testB();
		}
		public void testC() {
			new InnerC().testC();
		}
		
		private class InnerB extends B{
			@Override
			public void testB() {
				
				System.out.println("这是重写之后的testB方法");
			}
		}
		private class InnerC extends C{
			@Override
			public void testC() {
				System.out.println("这是重写之后的testC方法");
			}
		}
		
}


	class B{
		public void testB() {
		
	}
}

	class C{
		public void testC() {
		
	}
}

关键字final

在Java中声明类、属性和方法时，可使用关键字final来修饰,表示“最终”
final标记的类不能被继承
final标记的方法不能被子类重写
final标记的变量(成员变量或局部变量)即称为常量，名称大写，且只能被赋值一次。多个单词用_连接。
类：public final class Test{}
方法：public final void test (){}
变量：final String NAME_1=“张三”，不能使用默认final String name;得赋值

final static String NAME_1="" //final static一起修饰变量，就叫全局常量，静态就是全局的意思？

抽象类（abstract class）

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。

动物类普遍，鸟类，狗类更具体，动物类抽象类，抽象化处理，不写具体的方法体

用abstract关键字来修饰一个类时，这个类叫做抽象类；
用abstract来修饰一个方法时，该方法叫做抽象方法

抽象类不能被实例化。抽象类是用来作为父类被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。

public abstract class Animal {
	public abstract void test();//没有方法体
	
	public abstract void move();
	
	
}

class Dog extends Animal{

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

	@Override
	public void move() {
		System.out.println("跑");
		
	}
	
}
class Fish extends Animal{

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

	@Override
	public void move() {
		System.out.println("游");
		
	}
	
}

public class Test {
	public static void main(String[] args) {
		Dog d =new Dog();
		d.move();
	}
} //输出  游

练习：编写一个Employee类，声明为抽象类，包含如下三个属性：name，id，salary。提供必要的构造器和抽象方法：work()。对于Manager类来说，他既是员工，还具有奖金(bonus)的属性。请使用继承的思想，设计CommonEmployee类和Manager类，要求类中提供必要的方法进行属性访问。

public abstract class Employee {
	public Employee() {
		
	}
	String name;
	int ID;
	double salary;//有零有整
	
	public abstract void work();
}

class CommonEmployee extends Employee{
	
	public void setCommonEmployeeInfo(int id,String name,double salary) {
		super.ID=id;
		super.name=name;
		super.salary=salary;
		
	}
	public void getCommonEmployeeInfo() {
		System.out.println(super.ID);
		System.out.println(super.name);
		System.out.println(super.salary);
	}
	
	
	@Override
	public void work() {
		System.out.println("这是一个普通员工");		
	}
}

class Manager extends Employee{
	double bonus;
	String name;
	int ID;
	double salary;
	
	public void setManagerInfo(int id,String name,double salary,double bonus) {
		super.ID=id;
		super.name=name;
		super.salary=salary;
		this.bonus=bonus; //自己的属性
	}
	public void getMangerInfo() {
		System.out.println(super.ID);
		System.out.println(super.name);
		System.out.println(super.salary);
		System.out.println(this.bonus);
	}
	
	@Override
	public void work() {
		
		System.out.println("这是一个领导");
	}
	
}

public class Test {
	public static void main(String[] args) {
		CommonEmployee co =new CommonEmployee();
		co.work();
		co.setCommonEmployeeInfo(123,"张三", 4445.5);
		co.getCommonEmployeeInfo();
	}
}

模板方法设计模式

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式
当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式。

public abstract class Template {
	public abstract void code();
	
	public final void getTime(){
		long start = System.currentTimeMillis();
		code();
		long end = System.currentTimeMillis();
		System.out.println("执行时间是："+(end - start));
	}

}
class TestTmp  extends Template{
	public void code(){
		int k=0;
		for(int i = 0;i<999999;i++){
		k+=1;
} 
		}
	}

public class Test {
	public static void main(String[] args) {
		TestTmp t =new TestTmp();
		t.getTime();
	}
}

接口

从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现
接口就不是类，实际类
一个类可以实现多个接口，接口也可以继承其它接口
如果有继承父类又实现接口，则先写extends，后写implements
在这里插入图片描述

父类需要稳定的抽象，如果父类老在改，基于这个父类的子类都受到影响。有时需要在父类增加一些方法，所以只能新建一个接口，在接口上扩展方法，需要的子类自行实现接口。

新建一个person类

public abstract class Person1 {
	int age;
	String name;
	int sex;
	public abstract void showInfo();
	
}

新建cooking sing接口

public interface Cooking {
	void fry();  //炒菜
	
}

public interface Sing {
	void sing();
}

新建SCTeacher继承Person类，实现两个接口

/**
 * 描述一个会唱歌的厨子是老师
 * @author xrh
 *
 */
public class SCTeacher extends Person1 implements Cooking,Sing{
	String course;
	
	public void setInfo() {  //写完shouInfo 方法，再写一个set方法
		super.age=22;
		super.name="张三";
		super.sex=0;
		
		this.course="数学";
	}
	
	@Override
	public void showInfo() {
		System.out.println("一个会唱歌的厨子是老师的信息是");
		System.out.println(super.age);
		System.out.println(super.name);
		System.out.println(super.sex);
		System.out.println(this.course);
		
	}
	@Override
	public void fry() {
		System.out.println(super.name+"是一个会炒菜的");
		
	}
	@Override
	public void sing() {
		System.out.println(super.name+"是一个会唱歌的");
		
	}

}

test测试

public class Test {
	public static void main(String[] args) {
		SCTeacher sc =new SCTeacher();
		sc.setInfo();
		sc.showInfo();
		sc.fry();
		sc.sing();
	}
}

抽象类是对于一类事物的高度抽象，其中既有属性也有方法
接口是对方法的抽象，对一系列动作的抽象

工厂方法(FactoryMethod)

它通过面向对象的手法，将所要创建的具体对象的创建工作延迟到了子类，从而提供了一种扩展的策略，较好的解决了这种紧耦合的关系。

/**
 * 宝马车的产品接口
 * @author xrh
 *
 */
public interface BMW {
	//产品的信息介绍
	//车的发动方式
	
	void showInfo();
}
/**
 * 构建具体的宝马车类
 * @author xrh
 *
 */

class BMW3 implements BMW{

	@Override
	public void showInfo() {
		System.out.println("这是宝马3系");
		
	}
	
}

class BMW7 implements BMW{

	@Override
	public void showInfo() {
		System.out.println("这是宝马7系");
		
	}
	
}

class BMW5 implements BMW{

	@Override
	public void showInfo() {
		System.out.println("这是宝马5系");
		
	}
	
}

/**
 * 汽车生产工厂接口
 * @author xrh
 *
 */
public interface BMWFactory {
	BMW productBMW();
	
}
/**
 * 实现具体的车型的生产工厂
 * @author xrh
 *
 */

class BMW3Factory implements BMWFactory{
	public BMW productBMW() {
		System.out.println("生产宝马3系车");
		return new BMW3();
		
	}
}

class BMW5Factory implements BMWFactory{
	public BMW productBMW() {
		System.out.println("生产宝马5系车");
		return new BMW5();
		
	}
}

class BMW7Factory implements BMWFactory{
	public BMW productBMW() {
		System.out.println("生产宝马7系车");
		return new BMW7();
		
	}
}

public class Test {
	public static void main(String[] args) {
		//开发人员B的工作
		BMW b3 =new BMW3Factory().productBMW();
		b3.showInfo();
		
		BMW b5 =new BMW5Factory().productBMW();
		b5.showInfo();
		
		BMW b7 =new BMW7Factory().productBMW();
		b7.showInfo();
		
	}
}

通过工厂把new对象给隔离，通过产品的接口可以接受不同实际产品的实现类，实例的类名的改变不影响其他合作开发人员的编程

面向对象内容总结

在这里插入图片描述

X.. R H

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第五章高级类的特性2

关键字staticstatic String country;// 类变量不用实例化，直接类名.属性名使用，是类的一部分，被所有类的实例化对象所共享，也可以叫静态变量int age;//实例变量，只有实例化后才能使用，属于实例化对象的一部分，不能共用如果方法与调用者无关，则这样的方法通常被声明为类方法，由于不需要创建对象就可以调用类方法，从而简化了方法的调用public class Utils {//判断是否为空字符串 public static boolean isEmpty(String
复制链接

扫一扫